@slock-ai/daemon 0.46.0-play.20260508180641 → 0.46.1

package/dist/{chunk-MEY33LAG.js → chunk-XW57NR6Y.js}

@@ -1093,17 +1093,6 @@ Keep the user informed. They cannot see your internal reasoning, so:
 - For multi-step work, send short progress updates (e.g. "Working on step 2/3\u2026").
 - When done, summarize the result.
 - Keep updates concise \u2014 one or two sentences. Don't flood the chat.
-- For long answers where users need the conclusion first but details still matter, put the conclusion and next action outside any collapse, then use sanitized HTML details blocks for optional depth:
-
-\`\`\`html
-<details>
-<summary>Evidence, logs, or edge cases</summary>
-
-Detailed notes go here.
-</details>
-\`\`\`
-
-  Do not hide the main recommendation, blocker, or required action inside \`<details>\`; only fold supporting evidence, logs, alternatives, or extended rationale.
 
 ### Conversation etiquette
 
@@ -2569,8 +2558,8 @@ function runCursorModelsCommand() {
 }
 
 // src/drivers/gemini.ts
-import { spawn as spawn5 } from "child_process";
-import { writeFileSync as writeFileSync5, mkdirSync as mkdirSync3 } from "fs";
+import { execFileSync as execFileSync2, spawn as spawn5 } from "child_process";
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, writeFileSync as writeFileSync5 } from "fs";
 import path7 from "path";
 function buildGeminiSpawnEnv(ctx, platform = process.platform) {
   const { spawnEnv } = prepareCliTransport(ctx, { NO_COLOR: "1" }, platform);
@@ -2579,6 +2568,71 @@ function buildGeminiSpawnEnv(ctx, platform = process.platform) {
   }
   return spawnEnv;
 }
+function normalizeExecOutput2(raw) {
+  return Buffer.isBuffer(raw) ? raw.toString("utf8") : String(raw ?? "");
+}
+function buildGeminiArgs(config) {
+  const args = [
+    "--output-format",
+    "stream-json",
+    "--yolo",
+    // Gemini CLI headless mode is selected by -p/--prompt. Keep the actual
+    // prompt off argv and feed it through stdin below; this avoids Windows
+    // cmd.exe's 8191-character command-line limit and keeps long wake payloads
+    // below CreateProcess argv pressure too.
+    "-p",
+    ""
+  ];
+  if (config.model && config.model !== "default") {
+    args.push("--model", config.model);
+  }
+  if (config.sessionId) {
+    args.push("--resume", config.sessionId);
+  }
+  return args;
+}
+function resolveGeminiSpawn(commandArgs, deps = {}) {
+  const platform = deps.platform ?? process.platform;
+  if (platform !== "win32") {
+    return { command: resolveCommandOnPath("gemini", deps) ?? "gemini", args: commandArgs };
+  }
+  const execFileSyncFn = deps.execFileSyncFn ?? execFileSync2;
+  const existsSyncFn = deps.existsSyncFn ?? existsSync5;
+  const env = deps.env ?? process.env;
+  const winPath = path7.win32;
+  let geminiEntry = null;
+  try {
+    const globalRoot = normalizeExecOutput2(execFileSyncFn("npm", ["root", "-g"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"],
+      env
+    })).trim();
+    const candidate = winPath.join(globalRoot, "@google", "gemini-cli", "bundle", "gemini.js");
+    if (existsSyncFn(candidate)) geminiEntry = candidate;
+  } catch {
+  }
+  if (!geminiEntry) {
+    try {
+      const cmdPath = normalizeExecOutput2(execFileSyncFn("where.exe", ["gemini"], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
+        env
+      })).trim().split(/\r?\n/)[0];
+      const candidate = winPath.join(winPath.dirname(cmdPath), "node_modules", "@google", "gemini-cli", "bundle", "gemini.js");
+      if (existsSyncFn(candidate)) geminiEntry = candidate;
+    } catch {
+    }
+  }
+  if (!geminiEntry) {
+    throw new Error(
+      "Cannot resolve Gemini CLI entry point on Windows. Ensure @google/gemini-cli is installed globally via npm (npm i -g @google/gemini-cli)."
+    );
+  }
+  return {
+    command: process.execPath,
+    args: [geminiEntry, ...commandArgs]
+  };
+}
 var GeminiDriver = class {
   id = "gemini";
   lifecycle = {
@@ -2608,26 +2662,15 @@ var GeminiDriver = class {
     this.sessionId = ctx.config.sessionId || null;
     this.sessionAnnounced = false;
     this.writeGeminiSettings(ctx);
-    const args = [
-      "--output-format",
-      "stream-json",
-      "--yolo",
-      "-p",
-      ctx.prompt
-    ];
-    if (ctx.config.model && ctx.config.model !== "default") {
-      args.push("--model", ctx.config.model);
-    }
-    if (ctx.config.sessionId) {
-      args.push("--resume", ctx.config.sessionId);
-    }
+    const { command, args } = resolveGeminiSpawn(buildGeminiArgs(ctx.config));
     const spawnEnv = buildGeminiSpawnEnv(ctx);
-    const proc = spawn5("gemini", args, {
+    const proc = spawn5(command, args, {
       cwd: ctx.workingDirectory,
       stdio: ["pipe", "pipe", "pipe"],
       env: spawnEnv,
-      shell: process.platform === "win32"
+      shell: false
     });
+    proc.stdin?.end(ctx.prompt);
     return { process: proc };
   }
   parseLine(line) {
@@ -2729,16 +2772,13 @@ var GeminiDriver = class {
 // src/drivers/kimi.ts
 import { randomUUID } from "crypto";
 import { spawn as spawn6 } from "child_process";
-import { chmodSync, existsSync as existsSync5, readFileSync as readFileSync3, writeFileSync as writeFileSync6 } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync3, writeFileSync as writeFileSync6 } from "fs";
 import os3 from "os";
 import path8 from "path";
 var KIMI_WIRE_PROTOCOL_VERSION = "1.3";
 var KIMI_SYSTEM_PROMPT_FILE = ".slock-kimi-system.md";
 var KIMI_AGENT_FILE = ".slock-kimi-agent.yaml";
 var KIMI_MCP_FILE = ".slock-kimi-mcp.json";
-var KIMI_GENERATED_CONFIG_FILE = ".slock-kimi-config.toml";
-var SLOCK_KIMI_CONFIG_CONTENT_ENV = "SLOCK_KIMI_CONFIG_CONTENT";
-var SLOCK_KIMI_CONFIG_FILE_ENV = "SLOCK_KIMI_CONFIG_FILE";
 function parseToolArguments(raw) {
   if (typeof raw !== "string") return raw;
   try {
@@ -2747,73 +2787,6 @@ function parseToolArguments(raw) {
     return raw;
   }
 }
-function readKimiConfigSource(home = os3.homedir(), env = process.env) {
-  const inlineConfig = env[SLOCK_KIMI_CONFIG_CONTENT_ENV];
-  if (inlineConfig && inlineConfig.trim()) {
-    return {
-      raw: inlineConfig,
-      explicitPath: null,
-      sourcePath: SLOCK_KIMI_CONFIG_CONTENT_ENV
-    };
-  }
-  const explicitPath = env[SLOCK_KIMI_CONFIG_FILE_ENV];
-  const configPath = explicitPath && explicitPath.trim() ? explicitPath : path8.join(home, ".kimi", "config.toml");
-  try {
-    return {
-      raw: readFileSync3(configPath, "utf8"),
-      explicitPath: explicitPath && explicitPath.trim() ? explicitPath : null,
-      sourcePath: configPath
-    };
-  } catch {
-    return {
-      raw: null,
-      explicitPath: explicitPath && explicitPath.trim() ? explicitPath : null,
-      sourcePath: configPath
-    };
-  }
-}
-function buildKimiSpawnEnv(env = process.env) {
-  const spawnEnv = { ...env, FORCE_COLOR: "0", NO_COLOR: "1" };
-  delete spawnEnv[SLOCK_KIMI_CONFIG_CONTENT_ENV];
-  delete spawnEnv[SLOCK_KIMI_CONFIG_FILE_ENV];
-  return spawnEnv;
-}
-function buildKimiEffectiveEnv(ctx, overrideEnv) {
-  return {
-    ...process.env,
-    ...ctx.config.envVars || {},
-    ...overrideEnv || {}
-  };
-}
-function buildKimiLaunchOptions(ctx, opts = {}) {
-  const env = buildKimiEffectiveEnv(ctx, opts.env);
-  const source = readKimiConfigSource(opts.home ?? os3.homedir(), env);
-  const args = [];
-  let configFilePath = null;
-  let configContent = null;
-  if (source.explicitPath) {
-    configFilePath = source.explicitPath;
-  } else if (source.raw !== null && source.sourcePath === SLOCK_KIMI_CONFIG_CONTENT_ENV) {
-    configFilePath = path8.join(ctx.workingDirectory, KIMI_GENERATED_CONFIG_FILE);
-    configContent = source.raw;
-    if (opts.writeGeneratedConfig !== false) {
-      writeFileSync6(configFilePath, source.raw, { encoding: "utf8", mode: 384 });
-      chmodSync(configFilePath, 384);
-    }
-  }
-  if (configFilePath) {
-    args.push("--config-file", configFilePath);
-  }
-  if (ctx.config.model && ctx.config.model !== "default") {
-    args.push("--model", ctx.config.model);
-  }
-  return {
-    args,
-    env: buildKimiSpawnEnv(env),
-    configFilePath,
-    configContent
-  };
-}
 var KimiDriver = class {
   id = "kimi";
   lifecycle = {
@@ -2830,25 +2803,7 @@ var KimiDriver = class {
   };
   model = {
     detectedModelsVerifiedAs: "launchable",
-    toLaunchSpec: (modelId, ctx, opts) => {
-      if (!ctx) return { args: ["--model", modelId] };
-      const launchCtx = {
-        ...ctx,
-        config: {
-          ...ctx.config,
-          model: modelId
-        }
-      };
-      const launch = buildKimiLaunchOptions(launchCtx, {
-        home: opts?.home,
-        writeGeneratedConfig: false
-      });
-      return {
-        args: launch.args,
-        env: launch.env,
-        configFiles: launch.configFilePath ? [launch.configFilePath] : void 0
-      };
-    }
+    toLaunchSpec: (modelId) => ({ args: ["--model", modelId] })
   };
   supportsStdinNotification = true;
   mcpToolPrefix = "";
@@ -2882,7 +2837,7 @@ var KimiDriver = class {
     const systemPromptPath = path8.join(ctx.workingDirectory, KIMI_SYSTEM_PROMPT_FILE);
     const agentFilePath = path8.join(ctx.workingDirectory, KIMI_AGENT_FILE);
     const mcpConfigPath = path8.join(ctx.workingDirectory, KIMI_MCP_FILE);
-    if (!isResume || !existsSync5(systemPromptPath)) {
+    if (!isResume || !existsSync6(systemPromptPath)) {
       writeFileSync6(systemPromptPath, ctx.prompt, "utf8");
     }
     writeFileSync6(agentFilePath, [
@@ -2900,7 +2855,6 @@ var KimiDriver = class {
         }
       }
     }), "utf8");
-    const launch = buildKimiLaunchOptions(ctx);
     const args = [
       "--wire",
       "--yolo",
@@ -2909,13 +2863,16 @@ var KimiDriver = class {
       "--mcp-config-file",
       mcpConfigPath,
       "--session",
-      this.sessionId,
-      ...launch.args
+      this.sessionId
     ];
+    if (ctx.config.model && ctx.config.model !== "default") {
+      args.push("--model", ctx.config.model);
+    }
+    const spawnEnv = { ...process.env, FORCE_COLOR: "0", NO_COLOR: "1" };
     const proc = spawn6("kimi", args, {
       cwd: ctx.workingDirectory,
       stdio: ["pipe", "pipe", "pipe"],
-      env: launch.env,
+      env: spawnEnv,
       shell: process.platform === "win32"
     });
     proc.stdin?.write(JSON.stringify({
@@ -3032,9 +2989,14 @@ var KimiDriver = class {
     return detectKimiModels();
   }
 };
-function detectKimiModels(home = os3.homedir(), opts = {}) {
-  const raw = readKimiConfigSource(home, opts.env).raw;
-  if (raw === null) return null;
+function detectKimiModels(home = os3.homedir()) {
+  const configPath = path8.join(home, ".kimi", "config.toml");
+  let raw;
+  try {
+    raw = readFileSync3(configPath, "utf8");
+  } catch {
+    return null;
+  }
   const models = [];
   const sectionRe = /^\s*\[models(?:\.([^\]]+)|"\.[^"]+"|\."[^"]+")\s*\]\s*$/gm;
   const lineRe = /^\s*\[models\.(.+?)\s*\]\s*$/gm;

package/dist/core.js

@@ -9,7 +9,7 @@ import {
   resolveSlockCliPath,
   resolveWorkspaceDirectoryPath,
   scanWorkspaceDirectories
-} from "./chunk-MEY33LAG.js";
+} from "./chunk-XW57NR6Y.js";
 import {
   subscribeDaemonLogs
 } from "./chunk-Z3PCMYZO.js";

package/dist/index.js

@@ -3,7 +3,7 @@ import {
   DAEMON_CLI_USAGE,
   DaemonCore,
   parseDaemonCliArgs
-} from "./chunk-MEY33LAG.js";
+} from "./chunk-XW57NR6Y.js";
 import "./chunk-Z3PCMYZO.js";
 
 // src/index.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slock-ai/daemon",
-  "version": "0.46.0-play.20260508180641",
+  "version": "0.46.1",
   "type": "module",
   "bin": {
     "slock-daemon": "dist/index.js"