akm-cli 0.9.0-rc.0 → 0.9.0-rc.13

package/dist/setup/detect.js

@@ -10,9 +10,9 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { runManagedSubprocess } from "../core/subprocess.js";
 import { defaultWhich } from "../integrations/agent/detect.js";
 import { SESSION_LOG_HARNESSES } from "../integrations/harnesses/index.js";
-import { spawn } from "../runtime.js";
 import { detectHarnessConfigs } from "./harness-config-import.js";
 let detectOverrides;
 /** TEST-ONLY. Swap the network/host probes; pass undefined to restore. */
@@ -51,14 +51,12 @@ export async function detectOllama() {
     catch {
         // HTTP failed — try CLI fallback
     }
-    // CLI fallback
+    // CLI fallback — bounded (10 s) so a wedged `ollama` can't hang detection.
     try {
-        const proc = spawn(["ollama", "list"], {
-            stdout: "pipe",
-            stderr: "pipe",
+        const { stdout: text, exitCode } = await runManagedSubprocess(["ollama", "list"], {
+            capture: true,
+            timeoutMs: 10_000,
         });
-        const text = await new Response(proc.stdout).text();
-        const exitCode = await proc.exited;
         if (exitCode === 0 && text.trim()) {
             const lines = text.trim().split("\n").slice(1); // skip header
             result.models = lines

package/dist/setup/detected-engines.js

@@ -0,0 +1,136 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+const CHAT_SUFFIX = "/chat/completions";
+export function normalizeChatCompletionsEndpoint(input) {
+    const url = new URL(input);
+    if (url.protocol !== "http:" && url.protocol !== "https:")
+        throw new Error("endpoint must use http or https");
+    if (url.username || url.password || url.search || url.hash)
+        throw new Error("endpoint cannot contain credentials, query, or fragment");
+    let pathname = url.pathname.replace(/\/+$/, "");
+    if (!pathname.endsWith(CHAT_SUFFIX)) {
+        if (!pathname.endsWith("/v1") && !pathname.includes("/openai"))
+            pathname += "/v1";
+        pathname += CHAT_SUFFIX;
+    }
+    url.pathname = pathname;
+    return url.toString().replace(/\/$/, "");
+}
+export function engineFingerprint(engine) {
+    return engine.kind === "llm"
+        ? `llm:${normalizeChatCompletionsEndpoint(engine.endpoint)}`
+        : `agent:${engine.platform}`;
+}
+export async function verifyOpenAiCompatibleEndpoint(candidate, fetchFn = fetch) {
+    let endpoint;
+    try {
+        endpoint = normalizeChatCompletionsEndpoint(candidate.endpoint);
+    }
+    catch (error) {
+        return { ok: false, reason: error instanceof Error ? error.message : String(error) };
+    }
+    if (!candidate.model.trim())
+        return { ok: false, reason: "no detected model" };
+    const credential = candidate.apiKeyEnvVar ? process.env[candidate.apiKeyEnvVar] : undefined;
+    if (candidate.apiKeyEnvVar && !credential) {
+        return { ok: false, reason: `required credential ${candidate.apiKeyEnvVar} is unavailable` };
+    }
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 10_000);
+    timer.unref?.();
+    try {
+        const response = await fetchFn(endpoint, {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                ...(credential ? { authorization: `Bearer ${credential}` } : {}),
+            },
+            body: JSON.stringify({
+                model: candidate.model,
+                messages: [{ role: "user", content: "Reply OK" }],
+                max_tokens: 1,
+                stream: false,
+            }),
+            signal: controller.signal,
+        });
+        if (!response.ok)
+            return { ok: false, reason: `HTTP ${response.status}` };
+        const body = (await response.json());
+        if (typeof body.choices?.[0]?.message?.content !== "string") {
+            return { ok: false, reason: "response did not contain choices[0].message.content" };
+        }
+        return { ok: true, endpoint };
+    }
+    catch (error) {
+        return { ok: false, reason: error instanceof Error ? error.message : String(error) };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+function slug(value) {
+    const normalized = value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-|-$/g, "");
+    return normalized && /^[a-z]/.test(normalized) ? normalized : "local";
+}
+function availableName(config, preferred, fingerprint) {
+    for (const [name, engine] of Object.entries(config.engines ?? {}).sort(([left], [right]) => left.localeCompare(right))) {
+        if (engineFingerprint(engine) === fingerprint)
+            return name;
+    }
+    const base = slug(preferred);
+    if (!config.engines?.[base])
+        return base;
+    for (let suffix = 2;; suffix++) {
+        const candidate = `${base}-${suffix}`;
+        if (!config.engines?.[candidate])
+            return candidate;
+    }
+}
+/** Insert or reuse an LLM engine by canonical endpoint without modifying a match. */
+export function upsertDetectedLlmEngine(config, candidate) {
+    const endpoint = normalizeChatCompletionsEndpoint(candidate.endpoint);
+    const fingerprint = `llm:${endpoint}`;
+    const name = availableName(config, candidate.provider, fingerprint);
+    const existing = config.engines?.[name];
+    const reused = existing !== undefined && engineFingerprint(existing) === fingerprint;
+    const engines = reused
+        ? config.engines
+        : {
+            ...(config.engines ?? {}),
+            [name]: {
+                kind: "llm",
+                provider: candidate.provider,
+                endpoint,
+                model: candidate.model,
+                ...(candidate.apiKeyEnvVar ? { apiKey: `\${${candidate.apiKeyEnvVar}}` } : {}),
+            },
+        };
+    const defaults = { ...(config.defaults ?? {}) };
+    const currentDefault = defaults.llmEngine;
+    if (!currentDefault ||
+        (config.engines?.[currentDefault] && engineFingerprint(config.engines[currentDefault]) === fingerprint)) {
+        defaults.llmEngine = name;
+    }
+    if (!defaults.engine)
+        defaults.engine = defaults.llmEngine ?? name;
+    return { config: { ...config, engines, defaults }, name, reused };
+}
+/** Insert or reuse an agent engine by canonical platform without modifying a match. */
+export function upsertDetectedAgentEngine(config, platform) {
+    const fingerprint = `agent:${platform}`;
+    const name = availableName(config, platform, fingerprint);
+    const existing = config.engines?.[name];
+    const reused = existing !== undefined && engineFingerprint(existing) === fingerprint;
+    const engines = reused ? config.engines : { ...(config.engines ?? {}), [name]: { kind: "agent", platform } };
+    const defaults = { ...(config.defaults ?? {}) };
+    const currentDefault = defaults.engine;
+    if (!currentDefault ||
+        (config.engines?.[currentDefault] && engineFingerprint(config.engines[currentDefault]) === fingerprint)) {
+        defaults.engine = name;
+    }
+    return { config: { ...config, engines, defaults }, name, reused };
+}

package/dist/setup/engine-config.js

@@ -0,0 +1,100 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+import { ConfigError } from "../core/errors.js";
+export function readCurrentLlmEngine(config) {
+    const name = config.defaults?.llmEngine;
+    const engine = name ? config.engines?.[name] : undefined;
+    if (!engine || engine.kind !== "llm")
+        return undefined;
+    const { kind: _kind, supportsJsonSchema, timeoutMs, ...connection } = engine;
+    return {
+        ...connection,
+        ...(timeoutMs !== undefined ? { timeoutMs } : {}),
+        ...(supportsJsonSchema !== undefined ? { capabilities: { structuredOutput: supportsJsonSchema } } : {}),
+    };
+}
+export function readAgentEngineSelection(config) {
+    const engines = {};
+    for (const [name, engine] of Object.entries(config.engines ?? {})) {
+        if (engine.kind === "agent")
+            engines[name] = { ...engine };
+    }
+    const defaultName = config.defaults?.engine;
+    const defaultIsAgent = defaultName && config.engines?.[defaultName]?.kind === "agent";
+    if (Object.keys(engines).length === 0 && !defaultIsAgent)
+        return undefined;
+    return { ...(defaultIsAgent ? { default: defaultName } : {}), engines };
+}
+/** Write an OpenAI-compatible connection as a named LLM engine. */
+export function writeLlmEngine(config, llm) {
+    const name = config.defaults?.llmEngine ?? "default";
+    if (!llm) {
+        const engines = { ...(config.engines ?? {}) };
+        if (engines[name]?.kind === "llm")
+            delete engines[name];
+        const defaults = { ...(config.defaults ?? {}) };
+        delete defaults.llmEngine;
+        if (defaults.engine === name)
+            delete defaults.engine;
+        return { engines, defaults };
+    }
+    if (config.engines?.[name] && config.engines[name].kind !== "llm") {
+        throw new ConfigError(`Cannot configure LLM engine ${JSON.stringify(name)} because that name belongs to an agent engine.`, "INVALID_CONFIG_FILE");
+    }
+    const endpoint = llm.endpoint.endsWith("/chat/completions")
+        ? llm.endpoint
+        : `${llm.endpoint.replace(/\/$/, "")}/chat/completions`;
+    const { capabilities, ...connection } = llm;
+    return {
+        engines: {
+            ...(config.engines ?? {}),
+            [name]: {
+                ...connection,
+                kind: "llm",
+                endpoint,
+                ...(capabilities?.structuredOutput !== undefined ? { supportsJsonSchema: capabilities.structuredOutput } : {}),
+            },
+        },
+        defaults: { ...(config.defaults ?? {}), engine: config.defaults?.engine ?? name, llmEngine: name },
+    };
+}
+/** Merge setup-selected agent engines without translating profile-shaped data. */
+export function writeAgentEngines(config, selection) {
+    for (const [name, engine] of Object.entries(selection?.engines ?? {})) {
+        const existing = config.engines?.[name];
+        if (existing && existing.kind !== engine.kind) {
+            throw new ConfigError(`Cannot configure ${engine.kind} engine ${JSON.stringify(name)} because that name belongs to an ${existing.kind} engine.`, "INVALID_CONFIG_FILE");
+        }
+    }
+    const defaults = { ...(config.defaults ?? {}) };
+    if (selection?.disabled) {
+        const currentDefault = defaults.engine;
+        if (currentDefault && config.engines?.[currentDefault]?.kind === "agent") {
+            const llmDefault = defaults.llmEngine;
+            if (llmDefault && config.engines?.[llmDefault]?.kind === "llm")
+                defaults.engine = llmDefault;
+            else
+                delete defaults.engine;
+        }
+    }
+    if (selection?.default)
+        defaults.engine = selection.default;
+    const engines = { ...(config.engines ?? {}), ...(selection?.engines ?? {}) };
+    const selectedEngine = selection?.default ? engines[selection.default] : undefined;
+    if (selection?.default && selectedEngine && selectedEngine.kind !== "agent") {
+        throw new ConfigError(`Cannot select agent engine ${JSON.stringify(selection.default)} because that name belongs to an LLM engine.`, "INVALID_CONFIG_FILE");
+    }
+    if (selection?.default && !engines[selection.default]) {
+        engines[selection.default] = {
+            kind: "agent",
+            platform: selection.default,
+        };
+    }
+    return { engines, defaults };
+}
+export function cloneLlmConnection(llm) {
+    if (!llm)
+        return undefined;
+    return JSON.parse(JSON.stringify(llm));
+}

package/dist/setup/registry-stash-loader.js

@@ -30,7 +30,7 @@ const FALLBACK_STASHES = [
     {
         id: "itlackey/akm-stash",
         name: "itlackey/akm-stash",
-        description: "Official AKM onboarding stash",
+        description: "Official AKM onboarding bundle",
         url: "https://github.com/itlackey/akm-stash",
         source: "fallback",
         defaultSelected: true,
@@ -38,7 +38,7 @@ const FALLBACK_STASHES = [
     {
         id: "andrewyng/context-hub",
         name: "andrewyng/context-hub",
-        description: "Optional community prompt and context stash",
+        description: "Optional community prompt and context bundle",
         url: "https://github.com/andrewyng/context-hub",
         source: "fallback",
         defaultSelected: false,
@@ -53,7 +53,7 @@ export function _setLoadSetupStashesForTests(fake) {
 }
 // ── Loader ──────────────────────────────────────────────────────────────────
 /**
- * Fetch available stashes from the registry and map to SetupStashEntry[].
+ * Fetch available stashes from the registry and map to SetupBundleEntry[].
  *
  * Falls back to FALLBACK_STASHES on network failure, parse error, or
  * empty response — setup never crashes due to a registry outage.

package/dist/setup/semantic-assets.js

@@ -11,9 +11,11 @@ import os from "node:os";
 import path from "node:path";
 import * as p from "../cli/clack.js";
 import { isHttpUrl } from "../core/common.js";
-import { closeDatabase, isVecAvailable, openIndexDatabase } from "../indexer/db/db.js";
+import { runManagedSubprocess } from "../core/subprocess.js";
 import { checkEmbeddingAvailability, DEFAULT_LOCAL_MODEL, isTransformersAvailable } from "../llm/embedder.js";
-import { getDirname, spawn } from "../runtime.js";
+import { getDirname } from "../runtime.js";
+import { closeDatabase, openIndexDatabase } from "../storage/repositories/index-connection.js";
+import { isVecAvailable } from "../storage/repositories/index-vec-repository.js";
 // Approximate first-download sizes used in the setup note.
 // LOCAL_MODEL_APPROX_SIZE_MB tracks the default local model (DEFAULT_LOCAL_MODEL).
 const LOCAL_MODEL_APPROX_SIZE_MB = 130;
@@ -46,15 +48,16 @@ export async function prepareSemanticSearchAssets(config) {
             spin.start("Installing @huggingface/transformers...");
             try {
                 const pkgRoot = path.resolve(getDirname(import.meta.url), "../..");
-                const proc = spawn(["bun", "add", "@huggingface/transformers"], {
+                // Bounded (10 min) so a stalled `bun add` can't hang setup forever.
+                const result = await runManagedSubprocess(["bun", "add", "@huggingface/transformers"], {
+                    capture: true,
                     cwd: pkgRoot,
-                    stdout: "pipe",
-                    stderr: "pipe",
+                    timeoutMs: 10 * 60_000,
                 });
-                await proc.exited;
-                if (proc.exitCode !== 0) {
-                    const stderr = await new Response(proc.stderr).text();
-                    throw new Error(stderr || `exit code ${proc.exitCode}`);
+                if (result.spawnError)
+                    throw result.spawnError;
+                if (result.exitCode !== 0) {
+                    throw new Error(result.stderr || `exit code ${result.exitCode}`);
                 }
                 spin.stop("@huggingface/transformers installed.");
             }