@kenkaiiii/ggcoder 5.24.0 → 5.26.0

package/dist/app-sidecar.js

@@ -38,7 +38,8 @@ import { sessionToMarkdown, defaultExportFilename, } from "./core/session-export
 import { AuthStorage } from "./core/auth-storage.js";
 import { cleanupToolOutputs } from "./tools/overflow.js";
 import { readCappedBody } from "./utils/http-body.js";
-import { fetchSubscriptionUsage, MOONSHOT_OAUTH_KEY, SubscriptionUsageError, XIAOMI_CREDITS_KEY, } from "@kenkaiiii/gg-core";
+import { fetchSubscriptionUsage, MOONSHOT_OAUTH_KEY, SubscriptionUsageError, XIAOMI_CREDITS_KEY, discoverLocalModels, findProbedModel, formatLocalModelId, parseLocalModelId, probeEndpoint, toModelInfo as localModelInfo, } from "@kenkaiiii/gg-core";
+import { LocalEndpointError, addCustomEndpoint, listAllEndpoints, removeCustomEndpoint, syncEndpointCredentials, } from "./core/local-endpoint-store.js";
 import { loginAnthropic } from "./core/oauth/anthropic.js";
 import { loginOpenAI } from "./core/oauth/openai.js";
 import { loginGemini } from "./core/oauth/gemini.js";
@@ -46,7 +47,7 @@ import { loginKimi } from "./core/oauth/kimi.js";
 import { AUTH_PROVIDERS } from "./core/auth-providers.js";
 import { ensureAppDirs, loadSavedSettings } from "./config.js";
 import { SettingsManager } from "./core/settings-manager.js";
-import { getModel, getDefaultThinkingLevel, getContextWindow, MODELS, } from "./core/model-registry.js";
+import { getModel, getDefaultThinkingLevel, getContextWindow, getAllModels, clearRuntimeModels, registerRuntimeModels, } from "./core/model-registry.js";
 import { resolveStartOrFallback } from "./core/resolve-start.js";
 import { getGitBranch, getGitDirtyFileCount, isGitRepo } from "./utils/git.js";
 import { getGitHubOpenCounts, getGitHubRepoSlug } from "./utils/github.js";
@@ -620,6 +621,13 @@ async function main() {
     });
     const usageCache = new Map();
     const usageRequests = new Map();
+    // Last snapshot that actually carried windows, per provider. Replayed while a
+    // fetch is failing so the title meter never blinks out of existence. Bounded
+    // by USAGE_LAST_GOOD_MAX_AGE_MS — a provider that never recovers must stop
+    // reporting rather than freeze a percentage (and a long-past reset time) on
+    // screen forever. The 429 backoff alone runs to 24h, far past any usefulness.
+    const usageLastGood = new Map();
+    const USAGE_LAST_GOOD_MAX_AGE_MS = 30 * 60_000;
     // 429 backoff: quota endpoints are auxiliary UI data. Honor Retry-After when
     // provided; otherwise retain the unavailable snapshot for 30 minutes. Clamp
     // the provider value so a malformed header can neither hammer the endpoint
@@ -634,6 +642,9 @@ async function main() {
         // Moonshot platform API key is metered per-token, not per plan window.
         const authKey = provider === "moonshot" ? MOONSHOT_OAUTH_KEY : provider;
         if (!(await auth.hasProviderAuth(authKey))) {
+            // Logged out: drop the replay cache so a later login on a DIFFERENT
+            // account can never inherit the previous one's numbers.
+            usageLastGood.delete(provider);
             return { provider, displayName, connected: false, windows: [], fetchedAt: Date.now() };
         }
         try {
@@ -677,6 +688,18 @@ async function main() {
                 ...(backoffMs !== undefined && { backoffMs: String(backoffMs) }),
             });
             const connected = await auth.hasProviderAuth(authKey);
+            // Transient failures (notably the 429s these auxiliary quota endpoints
+            // hand out) must not blank the meter. Keep serving the last good
+            // snapshot, flagged `stale`, so the bar stays put instead of flickering
+            // out for the whole backoff window and back in on the next success.
+            // Past the max age it's dropped — no data beats confidently wrong data.
+            const lastGood = usageLastGood.get(provider);
+            if (lastGood && Date.now() - lastGood.fetchedAt >= USAGE_LAST_GOOD_MAX_AGE_MS) {
+                usageLastGood.delete(provider);
+            }
+            else if (connected && lastGood) {
+                return { ...lastGood, stale: true };
+            }
             return {
                 provider,
                 displayName,
@@ -698,6 +721,11 @@ async function main() {
         usageRequests.set(provider, request);
         try {
             const result = await request;
+            // Never re-store a replay — it would keep its original `fetchedAt`, but
+            // writing it back muddies the "last GOOD" contract for no gain.
+            if (result.connected && !result.error && !result.stale && result.windows.length > 0) {
+                usageLastGood.set(provider, result);
+            }
             // Anthropic can return utilization before it assigns reset timestamps
             // (notably before the account's first active request). Retry that partial
             // snapshot quickly; complete snapshots keep the normal one-minute cache.
@@ -1116,6 +1144,25 @@ async function createSession(deps, opts) {
             // /help
             .replaceAll(/see \/help/gi, "check the help menu"));
     }
+    /**
+     * Guidance for a connection failure against the ACTIVE local endpoint, or
+     * undefined when that isn't the situation (so the generic wording stands).
+     * "Disable your VPN / allow us through the firewall" is useless advice for a
+     * server running on this machine — name what the user has to restart.
+     */
+    function localNetworkGuidance(source) {
+        if (source !== "network")
+            return undefined;
+        const state = session.getState();
+        if (state.provider !== "local")
+            return undefined;
+        const parsed = parseLocalModelId(state.model);
+        const probe = localProbes.find((p) => p.endpoint.id === parsed?.endpointId);
+        if (!probe)
+            return undefined;
+        return (`${probe.endpoint.label} stopped responding at ${probe.endpoint.baseUrl}. ` +
+            "Start it again and retry, or pick another model.");
+    }
     // Turn any thrown value into the same clear headline/message/guidance shape
     // the TUI shows (see gg-ai's formatError) instead of a bare `err.message`, log
     // the full detail, and broadcast it under `type` ("error" or "ken_error").
@@ -1125,7 +1172,7 @@ async function createSession(deps, opts) {
     function broadcastError(type, logLabel, err) {
         const f = formatError(err);
         const message = f.message ? desktopGuidance(f.message) : undefined;
-        const guidance = desktopGuidance(f.guidance);
+        const guidance = localNetworkGuidance(f.source) ?? desktopGuidance(f.guidance);
         captureSidecarError(err, `app-sidecar.${logLabel.replaceAll(" ", "-")}`, {
             scope: type,
             ...(f.provider ? { provider: f.provider } : {}),
@@ -1233,6 +1280,99 @@ async function createSession(deps, opts) {
         }
     }
     log("INFO", "app-sidecar", "session ready", { provider, model, mode, chatAgent, cwd });
+    // ── Local models (Ollama / LM Studio / llama.cpp / vLLM) ──
+    // Probing four HTTP endpoints must never delay readiness, so this runs in the
+    // background (same shape as backgroundMcpConnect) and pushes a models_change
+    // frame when it lands.
+    let localProbes = [];
+    async function scanLocalModels(force) {
+        const endpoints = await listAllEndpoints();
+        const { probes, models } = await discoverLocalModels(endpoints, { force });
+        localProbes = probes;
+        // Only endpoints that answered get a credential: writing one for a server
+        // that isn't running would make `hasProviderAuth("local")` true forever.
+        await syncEndpointCredentials(probes.filter((probe) => probe.reachable).map((probe) => probe.endpoint));
+        clearRuntimeModels((m) => m.provider === "local");
+        registerRuntimeModels(models);
+        log("INFO", "app-sidecar", "local model scan", {
+            reachable: probes.filter((p) => p.reachable).length + "/" + probes.length,
+            models: String(models.length),
+        });
+        return probes;
+    }
+    /** Endpoint rows + models, in the shape the Local models UI renders. */
+    function localStatePayload() {
+        return {
+            endpoints: localProbes.map((probe) => ({
+                id: probe.endpoint.id,
+                label: probe.endpoint.label,
+                baseUrl: probe.endpoint.baseUrl,
+                kind: probe.endpoint.kind,
+                custom: probe.endpoint.custom === true,
+                reachable: probe.reachable,
+                ...(probe.reason ? { reason: probe.reason } : {}),
+                models: probe.models.map((m) => ({
+                    id: formatLocalModelId(probe.endpoint.id, m.rawId),
+                    rawId: m.rawId,
+                    contextWindow: m.contextWindow,
+                    contextWindowKnown: m.contextWindowKnown,
+                    supportsTools: m.supportsTools,
+                    supportsImages: m.supportsImages,
+                    supportsThinking: m.supportsThinking,
+                    ...(m.loaded === undefined ? {} : { loaded: m.loaded }),
+                })),
+            })),
+        };
+    }
+    /**
+     * Why `modelId` can't be selected right now, or `undefined` when it can.
+     * Two real footguns get a clear answer instead of a mid-run provider error:
+     * a model with no tool calling (can't drive the agent at all), and a server
+     * that has since been shut down.
+     */
+    async function localModelBlocker(modelId) {
+        const parsed = parseLocalModelId(modelId);
+        if (!parsed)
+            return undefined;
+        const endpoints = await listAllEndpoints();
+        const endpoint = endpoints.find((e) => e.id === parsed.endpointId);
+        if (!endpoint)
+            return `Unknown local endpoint "${parsed.endpointId}" — re-scan for local models.`;
+        const probe = await probeEndpoint(endpoint);
+        // Keep the cached view honest: this probe is fresher than the last scan.
+        localProbes = localProbes.map((p) => (p.endpoint.id === endpoint.id ? probe : p));
+        if (!probe.reachable) {
+            return `${endpoint.label} isn't running at ${endpoint.baseUrl}. Start it and scan again.`;
+        }
+        const model = probe.models.find((m) => m.rawId === parsed.rawId);
+        if (!model) {
+            return `${endpoint.label} no longer serves "${parsed.rawId}".`;
+        }
+        if (!model.supportsTools) {
+            return `${parsed.rawId} has no tool calling, so it can't run the agent. Pick a tool-capable model.`;
+        }
+        registerRuntimeModels(probe.models.map((m) => localModelInfo(m, endpoint)));
+        return undefined;
+    }
+    /**
+     * A restored per-project pref can ask for thinking on a local model that
+     * turns out not to reason (capabilities are only known after a probe). Drop
+     * the level once we know, so the first prompt doesn't carry a
+     * `reasoning_effort` the server rejects.
+     */
+    function clampLocalThinking() {
+        const st = session.getState();
+        const level = session.getThinkingLevel();
+        if (!level || st.provider !== "local")
+            return;
+        if (isThinkingLevelSupported(st.provider, st.model, level))
+            return;
+        session.setThinkingLevel(undefined);
+        broadcast("thinking_change", {
+            thinkingLevel: null,
+            supportedThinkingLevels: getSupportedThinkingLevels(st.provider, st.model),
+        });
+    }
     // Workspace extras (context window, git status, background tasks). Git state
     // is resolved once at startup and refreshed after every run; the context
     // window follows the active model.
@@ -1270,6 +1410,19 @@ async function createSession(deps, opts) {
             additionalRoots: session.getAdditionalRoots(),
         };
     }
+    void scanLocalModels(false)
+        .then(() => {
+        clampLocalThinking();
+        broadcast("extras", footerExtras());
+    })
+        .then(() => broadcast("models_change", { local: localStatePayload() }))
+        .catch((err) => {
+        // A discovery failure is never fatal — the user simply has no local
+        // models. Log it; don't push an error row into the transcript.
+        log("WARN", "app-sidecar", "local model scan failed", {
+            error: err instanceof Error ? err.message : String(err),
+        });
+    });
     // Refresh the GitHub counts and broadcast only on change. Transient failures
     // keep the last-known numbers so the chips don't flicker off on a timeout.
     async function refreshGitHubCounts() {
@@ -2249,6 +2402,50 @@ async function createSession(deps, opts) {
             });
             return;
         }
+        // Durable per-project journal (.gg/memory.md). Distinct from /memories,
+        // which is the personal chat-memory store shared by the chat agents.
+        if (method === "GET" && url === "/project-memory") {
+            void (async () => {
+                try {
+                    const sm = new SettingsManager(paths.settingsFile);
+                    await sm.load();
+                    json(res, 200, { enabled: sm.get("memoryEnabled") });
+                }
+                catch (error) {
+                    captureSidecarError(error, "app-sidecar.project-memory.get");
+                    json(res, 500, { error: error instanceof Error ? error.message : String(error) });
+                }
+            })();
+            return;
+        }
+        if (method === "POST" && url === "/project-memory") {
+            void readBody(req, res).then(async (raw) => {
+                if (raw === null)
+                    return;
+                let enabled;
+                try {
+                    enabled = JSON.parse(raw).enabled === true;
+                }
+                catch {
+                    json(res, 400, { error: "invalid JSON body" });
+                    return;
+                }
+                try {
+                    const sm = new SettingsManager(paths.settingsFile);
+                    await sm.load();
+                    await sm.set("memoryEnabled", enabled);
+                    // Applies from the next session: the journal handle is built during
+                    // AgentSession.initialize(), so a live run keeps its current behaviour
+                    // rather than half-applying the change mid-task.
+                    json(res, 200, { enabled });
+                }
+                catch (error) {
+                    captureSidecarError(error, "app-sidecar.project-memory.set");
+                    json(res, 500, { error: error instanceof Error ? error.message : String(error) });
+                }
+            });
+            return;
+        }
         if (method === "GET" && url === "/jiwa") {
             void jiwaStore
                 .snapshot()
@@ -2780,16 +2977,34 @@ async function createSession(deps, opts) {
                     description: c.description,
                     source: "built-in",
                 }));
+                // Desktop-safe registry actions belong in the same picker as workflows.
+                // Most registry commands have dedicated app controls or TUI-only flows;
+                // multi-root management has no other affordance, so expose only these.
+                const workspaceActions = [
+                    {
+                        name: "add-dir",
+                        aliases: ["adddir"],
+                        description: "Add another project folder to this workspace",
+                        source: "built-in",
+                    },
+                    {
+                        name: "remove-dir",
+                        aliases: ["removedir"],
+                        description: "Remove an added project folder from this workspace",
+                        source: "built-in",
+                    },
+                ];
                 const custom = (await loadCustomCommands(cwd))
-                    // A custom command can't shadow a built-in name.
-                    .filter((c) => !PROMPT_COMMANDS.some((b) => b.name === c.name))
+                    // A custom command can't shadow a built-in name or app action.
+                    .filter((c) => !PROMPT_COMMANDS.some((b) => b.name === c.name) &&
+                    !workspaceActions.some((action) => action.name === c.name))
                     .map((c) => ({
                     name: c.name,
                     aliases: [],
                     description: c.description,
                     source: "custom",
                 }));
-                json(res, 200, { commands: [...builtins, ...custom] });
+                json(res, 200, { commands: [...workspaceActions, ...builtins, ...custom] });
             })();
             return;
         }
@@ -3162,12 +3377,30 @@ async function createSession(deps, opts) {
                         loggedIn.push(p);
                 }
                 // Just the names, grouped by provider in registry order — the UI shows
-                // a clean multi-column list of model ids.
-                const models = MODELS.filter((m) => loggedIn.includes(m.provider)).map((m) => ({
-                    id: m.id,
-                    name: m.name,
-                    provider: m.provider,
-                }));
+                // a clean multi-column list of model ids. Local models come from the
+                // runtime registry (populated by the background scan) and are always
+                // listed: their "login" is the endpoint answering a probe.
+                const models = getAllModels()
+                    .filter((m) => m.provider === "local" || loggedIn.includes(m.provider))
+                    .map((m) => {
+                    if (m.provider !== "local") {
+                        return { id: m.id, name: m.name, provider: m.provider };
+                    }
+                    const probed = findProbedModel(localProbes, m.id);
+                    return {
+                        id: m.id,
+                        name: m.name,
+                        provider: m.provider,
+                        local: true,
+                        endpoint: probed?.endpoint.label ?? parseLocalModelId(m.id)?.endpointId,
+                        // A local model that can't call tools can't run the agent — the UI
+                        // renders it disabled rather than hiding it, so the user learns why.
+                        supportsTools: probed?.model.supportsTools ?? true,
+                        contextWindow: m.contextWindow,
+                        contextWindowKnown: probed?.model.contextWindowKnown ?? false,
+                        supportsThinking: m.supportsThinking,
+                    };
+                });
                 json(res, 200, { models });
             })();
             return;
@@ -3193,6 +3426,13 @@ async function createSession(deps, opts) {
                     json(res, 409, { error: "cannot switch model while running" });
                     return;
                 }
+                if (target.provider === "local") {
+                    const problem = await localModelBlocker(target.id);
+                    if (problem) {
+                        json(res, 409, { error: problem });
+                        return;
+                    }
+                }
                 await session.switchModel(target.provider, target.id);
                 // Ken follows GG Coder's model only while un-pinned; a user-set Ken
                 // override survives GG model switches untouched.
@@ -3619,6 +3859,84 @@ async function createSession(deps, opts) {
             return;
         }
         // ── Telegram config (mirrors `ggcoder telegram`) ─────────
+        // ── Local models ──────────────────────────────────────
+        // GET returns the last scan (cheap, no probing) so opening the modal is
+        // instant; POST /local/scan is the explicit refresh.
+        if (method === "GET" && url === "/local") {
+            json(res, 200, localStatePayload());
+            return;
+        }
+        if (method === "POST" && url === "/local/scan") {
+            void scanLocalModels(true)
+                .then(() => {
+                broadcast("models_change", { local: localStatePayload() });
+                json(res, 200, localStatePayload());
+            })
+                .catch((err) => {
+                broadcastError("error", "local model scan failed", err);
+                json(res, 500, { error: "Local model scan failed — see the sidecar log." });
+            });
+            return;
+        }
+        if (method === "POST" && url === "/local/endpoints") {
+            void readBody(req, res).then(async (raw) => {
+                if (raw === null)
+                    return;
+                let body;
+                try {
+                    body = JSON.parse(raw);
+                }
+                catch {
+                    json(res, 400, { error: "invalid JSON body" });
+                    return;
+                }
+                try {
+                    const endpoint = await addCustomEndpoint({
+                        baseUrl: body.baseUrl ?? "",
+                        ...(body.label ? { label: body.label } : {}),
+                        ...(body.apiKey ? { apiKey: body.apiKey } : {}),
+                    });
+                    await scanLocalModels(true);
+                    broadcast("models_change", { local: localStatePayload() });
+                    json(res, 200, {
+                        endpoint: { id: endpoint.id, label: endpoint.label },
+                        ...localStatePayload(),
+                    });
+                }
+                catch (err) {
+                    // Validation errors are the user's typo, not a system fault — 400 with
+                    // the exact reason, and nothing in the transcript.
+                    if (err instanceof LocalEndpointError) {
+                        json(res, 400, { error: err.message });
+                        return;
+                    }
+                    broadcastError("error", "add local endpoint failed", err);
+                    json(res, 500, { error: "Could not save the endpoint — see the sidecar log." });
+                }
+            });
+            return;
+        }
+        if (method === "DELETE" && url.startsWith("/local/endpoints/")) {
+            const id = decodeURIComponent(url.slice("/local/endpoints/".length));
+            void (async () => {
+                try {
+                    await removeCustomEndpoint(id);
+                    clearRuntimeModels((m) => m.provider === "local" && parseLocalModelId(m.id)?.endpointId === id);
+                    await scanLocalModels(true);
+                    broadcast("models_change", { local: localStatePayload() });
+                    json(res, 200, localStatePayload());
+                }
+                catch (err) {
+                    if (err instanceof LocalEndpointError) {
+                        json(res, 400, { error: err.message });
+                        return;
+                    }
+                    broadcastError("error", "remove local endpoint failed", err);
+                    json(res, 500, { error: "Could not remove the endpoint — see the sidecar log." });
+                }
+            })();
+            return;
+        }
         if (method === "GET" && url === "/telegram") {
             void loadTelegramConfig().then((cfg) => {
                 if (!cfg) {