@botconnector/bccli 0.4.2 → 0.4.3

package/dist/{acp-UYC6APR5.js → acp-NU4HZHQO.js}

@@ -181,7 +181,7 @@ function runtimeAgent(cwd, allowAll = false) {
     async run(text, onChunk, signal, io) {
       if (!rt) {
         const { parseCliArgs } = await import("./args-NRTZWWEV.js");
-        const { createRuntime } = await import("./setup-S4AJT6XE.js");
+        const { createRuntime } = await import("./setup-HVVHOIL4.js");
         rt = createRuntime({ cwd, args: { ...parseCliArgs([]), allowAll } });
       }
       if (io && !allowAll) rt.agent.askPermission = (req) => io.askPermission(req);

package/dist/{chunk-ZEPTUKNW.js → chunk-4W5SKQDC.js}

@@ -14,6 +14,11 @@ import { join } from "path";
 import { z } from "zod";
 
 // src/tools/sandbox.ts
+function winPathToWsl(winPath) {
+  const normalized = winPath.replace(/\\/g, "/");
+  const m = /^([A-Za-z]):\/(.*)$/.exec(normalized);
+  return m ? `/mnt/${m[1].toLowerCase()}/${m[2]}` : normalized;
+}
 function darwinProfile(cwd, network) {
   const writable = [cwd, "/tmp", "/private/tmp", "/dev", "/var/folders"].map((p) => `(subpath "${p}")`).join(" ");
   return [
@@ -57,6 +62,33 @@ function sandboxArgv(command, opts) {
       command
     ];
   }
+  if (opts.platform === "win32" && (opts.wslBwrap || process.env.BCCLI_WIN32_WSL_SANDBOX === "1")) {
+    const wslCwd = winPathToWsl(opts.cwd);
+    return [
+      "wsl.exe",
+      "--",
+      "bwrap",
+      "--ro-bind",
+      "/",
+      "/",
+      "--dev-bind",
+      "/dev",
+      "/dev",
+      "--proc",
+      "/proc",
+      "--bind",
+      wslCwd,
+      wslCwd,
+      "--tmpfs",
+      "/tmp",
+      "--die-with-parent",
+      ...opts.network ? [] : ["--unshare-net"],
+      "--",
+      "/bin/bash",
+      "-c",
+      command
+    ];
+  }
   return void 0;
 }
 
@@ -797,6 +829,7 @@ function normalizeGlobPath(path) {
 }
 
 export {
+  resolveShell,
   runHooks,
   renderBackgroundTasks,
   runCommand,

package/dist/{chunk-SVD4LHJC.js → chunk-6AUROP2E.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   contentText
-} from "./chunk-5YJ3ZQVR.js";
+} from "./chunk-XTOATEI6.js";
 
 // src/session.ts
 import { randomBytes } from "crypto";

package/dist/{chunk-IYR5PYA3.js → chunk-7I2ZGPUS.js}

@@ -5,7 +5,7 @@ import {
 } from "./chunk-HQW4BROS.js";
 import {
   createProvider
-} from "./chunk-5YJ3ZQVR.js";
+} from "./chunk-XTOATEI6.js";
 import {
   PRESETS,
   readCredentials

package/dist/{chunk-266SY3MC.js → chunk-FUJGHCWN.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/version.ts
-var VERSION = true ? "0.4.2" : "0.0.0-dev";
+var VERSION = true ? "0.4.3" : "0.0.0-dev";
 
 export {
   VERSION

package/dist/{chunk-H7XJDKJY.js → chunk-GWVLPN4B.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   listAllModels
-} from "./chunk-IYR5PYA3.js";
+} from "./chunk-7I2ZGPUS.js";
 import {
   hasKey,
   providerName,

package/dist/{chunk-R72OV7RF.js → chunk-QNUJHKEL.js}

@@ -24,7 +24,7 @@ import {
   resolvePath,
   runHooks,
   validateGlobPattern
-} from "./chunk-ZEPTUKNW.js";
+} from "./chunk-4W5SKQDC.js";
 import {
   createWebSearchTool,
   fetchTool
@@ -37,10 +37,10 @@ import {
 } from "./chunk-WFZKJY3R.js";
 import {
   addProviderKey
-} from "./chunk-H7XJDKJY.js";
+} from "./chunk-GWVLPN4B.js";
 import {
   listAllModels
-} from "./chunk-IYR5PYA3.js";
+} from "./chunk-7I2ZGPUS.js";
 import {
   providerName
 } from "./chunk-HQW4BROS.js";
@@ -50,14 +50,14 @@ import {
 } from "./chunk-3I5BW3ZT.js";
 import {
   Session
-} from "./chunk-SVD4LHJC.js";
+} from "./chunk-6AUROP2E.js";
 import {
   completionAssistantMessage,
   createProvider,
   hasPendingProgrammaticReplay,
   imageUserMessage,
   withFallbackProvider
-} from "./chunk-5YJ3ZQVR.js";
+} from "./chunk-XTOATEI6.js";
 import {
   expandEnvVars
 } from "./chunk-6M55UPES.js";
@@ -1914,14 +1914,14 @@ function createRepoMapTool() {
 }
 
 // src/tools/diagnostics.ts
-import { extname as extname3 } from "path";
+import { extname as extname3, relative as relative2 } from "path";
 import { z as z14 } from "zod";
 
 // src/lsp.ts
 import { spawn } from "child_process";
 import { readFileSync as readFileSync4 } from "fs";
 import { extname as extname2 } from "path";
-import { pathToFileURL } from "url";
+import { fileURLToPath, pathToFileURL } from "url";
 var LANGUAGE_IDS = {
   ".ts": "typescript",
   ".tsx": "typescriptreact",
@@ -1989,86 +1989,253 @@ function createLspParser(onMessage) {
     }
   };
 }
-function getDiagnostics(opts) {
-  return new Promise((resolve) => {
-    const child = spawn(opts.server.command, opts.server.args ?? [], {
-      cwd: opts.cwd,
-      stdio: ["pipe", "pipe", "ignore"],
-      shell: useShellForLsp(opts.server.command)
+function extractHoverText(contents) {
+  if (!contents) return "";
+  if (typeof contents === "string") return contents.trim();
+  if (Array.isArray(contents)) return contents.map(extractHoverText).filter(Boolean).join("\n\n");
+  if (typeof contents === "object" && "value" in contents && typeof contents.value === "string") {
+    return contents.value.trim();
+  }
+  return "";
+}
+function normalizeLocations(raw) {
+  const items = Array.isArray(raw) ? raw : raw ? [raw] : [];
+  const out = [];
+  for (const item of items) {
+    if (!item || typeof item !== "object") continue;
+    const rec = item;
+    const uri = rec.uri ?? rec.targetUri;
+    const start = rec.range?.start ?? rec.targetSelectionRange?.start ?? rec.targetRange?.start;
+    if (!uri) continue;
+    let path = uri;
+    try {
+      if (uri.startsWith("file:")) path = fileURLToPath(uri);
+    } catch {
+    }
+    out.push({
+      uri,
+      path,
+      line: start?.line ?? 0,
+      character: start?.character ?? 0
     });
-    const uri = pathToFileURL(opts.file).href;
-    let settled = false;
-    let nextId = 2;
-    const send = (msg) => {
-      try {
-        child.stdin.write(encodeLsp(msg));
-      } catch {
-      }
-    };
-    const finish = (diags) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      opts.signal?.removeEventListener("abort", onAbort);
-      send({ jsonrpc: "2.0", id: nextId++, method: "shutdown" });
-      send({ jsonrpc: "2.0", method: "exit" });
-      const killer = setTimeout(() => {
-        try {
-          child.kill();
-        } catch {
+  }
+  return out;
+}
+function createWarmLspClient(opts) {
+  let child;
+  let initPromise;
+  let nextId = 2;
+  const opened = /* @__PURE__ */ new Map();
+  const pendingRpc = /* @__PURE__ */ new Map();
+  const diagWaiters = /* @__PURE__ */ new Map();
+  const send = (msg) => {
+    try {
+      child?.stdin?.write(encodeLsp(msg));
+    } catch {
+    }
+  };
+  const resetState = () => {
+    child = void 0;
+    initPromise = void 0;
+    opened.clear();
+    for (const [, resolve] of pendingRpc) resolve(void 0);
+    pendingRpc.clear();
+    for (const [, waiters] of diagWaiters) {
+      for (const w of waiters) w([]);
+    }
+    diagWaiters.clear();
+  };
+  const ensureStarted = () => {
+    if (initPromise && child && !child.killed) return initPromise;
+    opened.clear();
+    initPromise = new Promise((resolveInit) => {
+      const proc = spawn(opts.server.command, opts.server.args ?? [], {
+        cwd: opts.cwd,
+        stdio: ["pipe", "pipe", "ignore"],
+        shell: useShellForLsp(opts.server.command)
+      });
+      child = proc;
+      let initSettled = false;
+      const settleInit = () => {
+        if (!initSettled) {
+          initSettled = true;
+          resolveInit();
         }
-      }, 500);
-      killer.unref?.();
-      resolve(diags);
-    };
-    const onAbort = () => finish([]);
-    if (opts.signal?.aborted) return finish([]);
-    opts.signal?.addEventListener("abort", onAbort, { once: true });
-    const timer = setTimeout(() => finish([]), opts.timeoutMs ?? 8e3);
-    const parser = createLspParser((msg) => {
-      if (msg.id === 1 && msg.result) {
-        send({ jsonrpc: "2.0", method: "initialized", params: {} });
-        let text = "";
-        try {
-          text = readFileSync4(opts.file, "utf8");
-        } catch {
+      };
+      const parser = createLspParser((msg) => {
+        if (msg.id === 1 && msg.result !== void 0) {
+          send({ jsonrpc: "2.0", method: "initialized", params: {} });
+          settleInit();
+          return;
         }
-        send({
-          jsonrpc: "2.0",
-          method: "textDocument/didOpen",
-          params: { textDocument: { uri, languageId: languageIdFor(opts.file), version: 1, text } }
-        });
-      }
-      if (msg.method === "textDocument/publishDiagnostics" && msg.params?.uri === uri) {
-        finish(
-          (msg.params.diagnostics ?? []).map((d) => ({
+        if (msg.id !== void 0 && pendingRpc.has(msg.id)) {
+          const fn = pendingRpc.get(msg.id);
+          pendingRpc.delete(msg.id);
+          fn?.(msg.result);
+          return;
+        }
+        if (msg.method === "textDocument/publishDiagnostics" && msg.params?.uri) {
+          const uri = msg.params.uri;
+          const diags = (msg.params.diagnostics ?? []).map((d) => ({
             line: d.range?.start?.line ?? 0,
             character: d.range?.start?.character ?? 0,
             severity: d.severity ?? 1,
             message: String(d.message ?? "")
-          }))
-        );
-      }
+          }));
+          const list = diagWaiters.get(uri);
+          if (list?.length) {
+            diagWaiters.delete(uri);
+            for (const w of list) w(diags);
+          }
+        }
+      });
+      proc.stdout?.on("data", (c) => parser.push(c));
+      proc.on("error", () => {
+        resetState();
+        settleInit();
+      });
+      proc.on("close", () => {
+        resetState();
+        settleInit();
+      });
+      send({
+        jsonrpc: "2.0",
+        id: 1,
+        method: "initialize",
+        params: { processId: process.pid, capabilities: {}, rootUri: pathToFileURL(opts.cwd).href }
+      });
     });
-    child.stdout?.on("data", (c) => parser.push(c));
-    child.on("error", () => finish([]));
-    child.on("close", () => finish([]));
-    send({
-      jsonrpc: "2.0",
-      id: 1,
-      method: "initialize",
-      params: { processId: process.pid, capabilities: {}, rootUri: pathToFileURL(opts.cwd).href }
+    return initPromise;
+  };
+  const syncDocument = (file) => {
+    const uri = pathToFileURL(file).href;
+    let text = "";
+    try {
+      text = readFileSync4(file, "utf8");
+    } catch {
+    }
+    const prevVersion = opened.get(uri);
+    if (prevVersion === void 0) {
+      opened.set(uri, 1);
+      send({
+        jsonrpc: "2.0",
+        method: "textDocument/didOpen",
+        params: { textDocument: { uri, languageId: languageIdFor(file), version: 1, text } }
+      });
+    } else {
+      const version = prevVersion + 1;
+      opened.set(uri, version);
+      send({
+        jsonrpc: "2.0",
+        method: "textDocument/didChange",
+        params: {
+          textDocument: { uri, version },
+          contentChanges: [{ text }]
+        }
+      });
+    }
+    return uri;
+  };
+  const request = (method, params, timeoutMs = opts.timeoutMs ?? 8e3) => new Promise((resolve) => {
+    const id = nextId++;
+    const timer = setTimeout(() => {
+      pendingRpc.delete(id);
+      resolve(void 0);
+    }, timeoutMs);
+    pendingRpc.set(id, (res) => {
+      clearTimeout(timer);
+      resolve(res);
     });
+    send({ jsonrpc: "2.0", id, method, params });
   });
+  return {
+    async diagnostics(file, timeoutMs = opts.timeoutMs ?? 8e3) {
+      await ensureStarted();
+      if (!child) return [];
+      const uri = pathToFileURL(file).href;
+      return new Promise((resolve) => {
+        const timer = setTimeout(() => {
+          const list2 = diagWaiters.get(uri) ?? [];
+          diagWaiters.set(
+            uri,
+            list2.filter((w) => w !== onDiag)
+          );
+          resolve([]);
+        }, timeoutMs);
+        const onDiag = (diags) => {
+          clearTimeout(timer);
+          resolve(diags);
+        };
+        const list = diagWaiters.get(uri) ?? [];
+        list.push(onDiag);
+        diagWaiters.set(uri, list);
+        syncDocument(file);
+      });
+    },
+    async hover(file, line, character, timeoutMs) {
+      await ensureStarted();
+      if (!child) return "";
+      const uri = syncDocument(file);
+      const res = await request("textDocument/hover", { textDocument: { uri }, position: { line, character } }, timeoutMs);
+      return extractHoverText(res?.contents);
+    },
+    async definition(file, line, character, timeoutMs) {
+      await ensureStarted();
+      if (!child) return [];
+      const uri = syncDocument(file);
+      const res = await request("textDocument/definition", { textDocument: { uri }, position: { line, character } }, timeoutMs);
+      return normalizeLocations(res);
+    },
+    async references(file, line, character, timeoutMs) {
+      await ensureStarted();
+      if (!child) return [];
+      const uri = syncDocument(file);
+      const res = await request(
+        "textDocument/references",
+        { textDocument: { uri }, position: { line, character }, context: { includeDeclaration: true } },
+        timeoutMs
+      );
+      return normalizeLocations(res);
+    },
+    async close() {
+      if (!child) return;
+      const proc = child;
+      send({ jsonrpc: "2.0", id: nextId++, method: "shutdown" });
+      send({ jsonrpc: "2.0", method: "exit" });
+      resetState();
+      const killer = setTimeout(() => {
+        try {
+          proc.kill();
+        } catch {
+        }
+      }, 200);
+      killer.unref?.();
+    }
+  };
 }
 
 // src/tools/diagnostics.ts
 var SEVERITY = { 1: "error", 2: "warning", 3: "info", 4: "hint" };
-var SCHEMA = z14.object({ path: z14.string().describe("File to check (absolute or relative to the working directory)") });
+var SCHEMA = z14.object({
+  path: z14.string().describe("File to check (absolute or relative to the working directory)"),
+  action: z14.enum(["diagnostics", "hover", "definition", "references"]).optional().describe("LSP query action, default diagnostics"),
+  line: z14.number().int().min(1).optional().describe("1-based line number for hover, definition, or references"),
+  character: z14.number().int().min(1).optional().describe("1-based column number for hover, definition, or references")
+});
 function createDiagnosticsTool(servers) {
+  const warmPool = /* @__PURE__ */ new Map();
+  const clientFor = (server, cwd) => {
+    const key = `${cwd}::${server.command}::${(server.args ?? []).join("\0")}`;
+    let client = warmPool.get(key);
+    if (!client) {
+      client = createWarmLspClient({ server, cwd, timeoutMs: 15e3 });
+      warmPool.set(key, client);
+    }
+    return client;
+  };
   return defineTool({
     name: "diagnostics",
-    description: 'Run the configured LSP server(s) on one file and return its diagnostics (errors/warnings). Configure servers under "lsp.servers" in ~/.bccli/config.json, e.g. { "extensions": [".ts"], "command": "typescript-language-server", "args": ["--stdio"] }.',
+    description: 'Query the configured LSP server(s) on a file for diagnostics (errors/warnings), hover docs, definition, or references. Configure servers under "lsp.servers" in ~/.bccli/config.json, e.g. { "extensions": [".ts"], "command": "typescript-language-server", "args": ["--stdio"] }.',
     schema: SCHEMA,
     kind: "read",
     target: (input) => input.path,
@@ -2079,7 +2246,24 @@ function createDiagnosticsTool(servers) {
       if (!server) {
         return { output: t("No LSP server is configured for {ext} files.", { ext: ext || "(none)" }), isError: true };
       }
-      const diags = await getDiagnostics({ server, cwd: ctx.cwd, file, timeoutMs: 15e3 });
+      const client = clientFor(server, ctx.cwd);
+      const action = input.action ?? "diagnostics";
+      const line0 = Math.max(0, (input.line ?? 1) - 1);
+      const char0 = Math.max(0, (input.character ?? 1) - 1);
+      if (action === "hover") {
+        const text = await client.hover(file, line0, char0, 15e3);
+        return { output: text || "No hover information." };
+      }
+      if (action === "definition" || action === "references") {
+        const locs = action === "definition" ? await client.definition(file, line0, char0, 15e3) : await client.references(file, line0, char0, 15e3);
+        if (!locs.length) return { output: `No ${action} found.` };
+        const formatted = locs.map((l) => {
+          const rel = relative2(ctx.cwd, l.path).replace(/\\/g, "/") || input.path;
+          return `${rel}:${l.line + 1}:${l.character + 1}`;
+        });
+        return { output: formatted.join("\n") };
+      }
+      const diags = await client.diagnostics(file, 15e3);
       if (!diags.length) return { output: "No diagnostics." };
       const lines = diags.map((d) => `${input.path}:${d.line + 1}:${d.character + 1} ${SEVERITY[d.severity] ?? "error"} ${d.message}`);
       return { output: lines.join("\n"), isError: diags.some((d) => d.severity === 1) };

package/dist/{chunk-C64KM37J.js → chunk-WDX62DFH.js}

@@ -2,7 +2,7 @@
 import {
   runCommand,
   runHooks
-} from "./chunk-ZEPTUKNW.js";
+} from "./chunk-4W5SKQDC.js";
 import {
   ConfigError
 } from "./chunk-RX4UQX43.js";
@@ -72,8 +72,12 @@ async function runPrint(rt, prompt, io = { out: process.stdout, err: process.std
           wroteText = true;
         } else {
           result += event.delta;
+          if (format === "stream-json") emit({ type: "text_delta", delta: event.delta });
         }
         break;
+      case "thinking":
+        if (format === "stream-json") emit({ type: "thinking_delta", delta: event.delta });
+        break;
       case "textReplace":
         result = event.text;
         break;

package/dist/{chunk-5YJ3ZQVR.js → chunk-XTOATEI6.js}

@@ -758,7 +758,7 @@ function createProvider(options) {
   const isBotConnectorCloud = /^https:\/\/api\.botconnector\.id\/v1\/?$/.test(baseURL) && apiKey?.startsWith("bc_live_");
   if (isBotConnectorCloud) {
     headers["x-botconnector-client"] = "bccli";
-    headers["x-botconnector-client-version"] = "0.4.2";
+    headers["x-botconnector-client-version"] = "0.4.3";
   }
   const useNativeResponses = isBotConnectorCloud && providerId === "bc-cloud" && model === "gpt-6-luna";
   const useResponsesWebSocket = useNativeResponses && Boolean(apiKey) && (fetchOverride === void 0 || responsesWebSocketFactory !== void 0);
@@ -789,7 +789,7 @@ function createProvider(options) {
         baseURL: baseURL.replace(/\/+$/, ""),
         defaultHeaders: {
           "x-botconnector-client": "bccli",
-          "x-botconnector-client-version": "0.4.2"
+          "x-botconnector-client-version": "0.4.3"
         }
       });
       lunaWs = responsesWebSocketFactory ? responsesWebSocketFactory(client) : new ResponsesWS(client, { reconnect: null });

package/dist/{chunk-TIMSYZIR.js → chunk-Z5NI5FIK.js}

@@ -91,7 +91,7 @@ function defaultLoginDeps() {
     fetch: globalThis.fetch,
     // Wiring NYATA jalur lama: persis runLogin lama (provider add + prompt key).
     legacyAdd: async (providerId, targetCwd) => {
-      const { runProviderCommand } = await import("./providerCli-5OZI2GQQ.js");
+      const { runProviderCommand } = await import("./providerCli-V2576JXE.js");
       const { parseCliArgs: parse } = await import("./args-NRTZWWEV.js");
       return runProviderCommand(parse(["provider", "add", providerId]), {
         env: process.env,