newcraw 1.0.2 → 1.0.4

package/dist/{gateway-IZYO6YFJ.js → gateway-SUXSILQL.js}

@@ -2,47 +2,55 @@
 import { createRequire as __newcrawCreateRequire } from "node:module";
 const require = __newcrawCreateRequire(import.meta.url);
 import {
-  getDomain,
-  getIdentity,
-  setIdentity
-} from "./chunk-OJIMOLIC.js";
-import "./chunk-XS6PU75S.js";
-import "./chunk-WWDVA4NV.js";
-import "./chunk-VQSCECTS.js";
-import "./chunk-HSJ6HYAO.js";
-import "./chunk-3LMXSKZ7.js";
-import "./chunk-XXU2NVOE.js";
-import "./chunk-JX5ZQYTQ.js";
-import "./chunk-XJQATPV7.js";
-import "./chunk-V5U6BHT2.js";
-import "./chunk-7ZFLZNOW.js";
-import "./chunk-VHS2MZQS.js";
-import "./chunk-QH2M65BR.js";
-import "./chunk-RUXIBQ3B.js";
-import "./chunk-JWXQNBBA.js";
-import "./chunk-2C43OXE7.js";
-import "./chunk-BWYKUDJR.js";
-import "./chunk-2EFL22PV.js";
-import "./chunk-U7S4MEYP.js";
-import "./chunk-UYRR6F5S.js";
+  showSetupScreens
+} from "./chunk-EUBZGAIN.js";
+import {
+  buildSkillMatchDirective,
+  createQueryOptions,
+  matchSkillForPrompt
+} from "./chunk-ARCEUG3V.js";
+import {
+  registerHealthProbe,
+  startPeriodicHealthCheck,
+  stopPeriodicHealthCheck
+} from "./chunk-2BVCVKKB.js";
+import "./chunk-Q2OBTLBI.js";
+import "./chunk-MUW3J7CP.js";
+import "./chunk-BJYXLCRS.js";
+import "./chunk-QJ7MQIHN.js";
 import "./chunk-TY3CCSAT.js";
-import "./chunk-LOIZNQOU.js";
-import "./chunk-INJSFEKL.js";
-import "./chunk-2UO3BFZH.js";
 import {
   createAssistantMessage,
   createUserMessage
-} from "./chunk-A7X6OCZE.js";
-import "./chunk-F3COCCAE.js";
-import "./chunk-53A4JHFW.js";
-import "./chunk-DEF3KFP7.js";
-import "./chunk-IIFUDVGS.js";
-import "./chunk-KQSHIOZK.js";
-import "./chunk-GZTCXXSS.js";
-import "./chunk-IM33F5CM.js";
-import "./chunk-ZYSVG4X3.js";
-import "./chunk-755HIAI3.js";
-import "./chunk-AXWJI6N5.js";
+} from "./chunk-IXFBUXQW.js";
+import {
+  init_sandbox,
+  shutdownSandboxPool,
+  tryInitSandboxPool
+} from "./chunk-MJLWBVZP.js";
+import "./chunk-JI4HCLK7.js";
+import {
+  getIdentity,
+  setIdentity
+} from "./chunk-JLVECHVJ.js";
+import "./chunk-2UO3BFZH.js";
+import "./chunk-QX5Y5CE5.js";
+import "./chunk-GVLJUD6R.js";
+import {
+  enableConfigs,
+  getGlobalConfig,
+  init_config
+} from "./chunk-U6IF5D3J.js";
+import "./chunk-NT7RDVDA.js";
+import "./chunk-QT5GS374.js";
+import {
+  init_log,
+  logError
+} from "./chunk-XYQZLDRB.js";
+import "./chunk-UYWZQVH5.js";
+import "./chunk-EHQ2M5B4.js";
+import "./chunk-HLBLZKZH.js";
+import "./chunk-D4OZACS2.js";
 
 // src/sessions/manager.ts
 var SessionManager = class {
@@ -80,95 +88,166 @@ var SessionManager = class {
 // src/gateway/agentCore.ts
 import { cwd as processCwd } from "process";
 var gatewayPermissionHandler = async (tool, _input, _context, _assistantMessage) => {
-  if (tool.isReadOnly()) {
-    return { result: true };
-  }
   return { result: true };
 };
-async function loadGatewayTools(domainId) {
-  const { getTools } = await import("./tools-3HOUIDM3.js");
-  const domain = getDomain(domainId);
-  const allTools = await getTools();
-  if (!domain) return allTools;
-  const allowedNames = new Set(domain.tools());
-  const filtered = allTools.filter((t) => allowedNames.has(t.name));
-  return filtered.length > 0 ? filtered : allTools;
-}
 function convertSessionHistory(history) {
   return history.map(
     (msg) => msg.role === "user" ? createUserMessage(msg.content) : createAssistantMessage(msg.content)
   );
 }
 async function gatewayQuery(options) {
-  const { ask } = await import("./ask-MGUO3L35.js");
-  const { setCwd } = await import("./state-MSCYLB6Y.js");
+  const { query } = await import("./query-BFEFOX4S.js");
+  const { getSystemPrompt } = await import("./prompts-MFESKNYZ.js");
+  const { getContext } = await import("./context-HVQCTO5R.js");
+  const { setCwd } = await import("./state-XBYIQ7R4.js");
   const identity = getIdentity();
   const domainId = options.domain ?? identity.domain;
   const cwd = options.cwd ?? processCwd();
   await setCwd(cwd);
-  const tools = options.tools ?? await loadGatewayTools(domainId);
-  const result = await ask({
-    commands: [],
-    safeMode: options.safeMode ?? false,
-    hasPermissionsToUseTool: gatewayPermissionHandler,
-    messageLogName: `gateway-${Date.now()}`,
-    prompt: options.prompt,
-    cwd,
-    tools,
-    verbose: false,
-    initialMessages: options.sessionMessages,
-    persistSession: false,
-    domain: domainId
-  });
+  const userMessage = createUserMessage(options.prompt);
+  const messages = [...options.sessionMessages ?? [], userMessage];
+  const messageLogName = `gateway-${Date.now()}`;
+  const [systemPrompt, context, queryOpts, skillMatch] = await Promise.all([
+    getSystemPrompt({ domain: domainId }),
+    getContext(),
+    createQueryOptions({
+      messages,
+      safeMode: options.safeMode,
+      messageLogName,
+      verbose: false,
+      persistSession: false
+    }),
+    matchSkillForPrompt(options.prompt)
+  ]);
+  if (skillMatch) {
+    systemPrompt.unshift(buildSkillMatchDirective(skillMatch));
+  }
+  const abortController = new AbortController();
+  for await (const m of query(
+    messages,
+    systemPrompt,
+    context,
+    gatewayPermissionHandler,
+    {
+      ...queryOpts,
+      abortController
+    }
+  )) {
+    messages.push(m);
+  }
+  const last = messages[messages.length - 1];
+  const resultText = last?.type === "assistant" ? last.message.content.find((c) => c.type === "text")?.text ?? "" : "";
   return {
-    resultText: result.resultText,
+    resultText,
     messages: [],
-    totalCost: result.totalCost
+    totalCost: 0
   };
 }
 async function* gatewayQueryStream(options) {
-  const { query } = await import("./query-GGIP6PWG.js");
-  const { getSystemPrompt } = await import("./prompts-LE6GK75N.js");
-  const { getContext } = await import("./context-WF3TTXQU.js");
-  const { setCwd } = await import("./state-MSCYLB6Y.js");
+  const { query } = await import("./query-BFEFOX4S.js");
+  const { getSystemPrompt } = await import("./prompts-MFESKNYZ.js");
+  const { getContext } = await import("./context-HVQCTO5R.js");
+  const { setCwd } = await import("./state-XBYIQ7R4.js");
   const identity = getIdentity();
   const domainId = options.domain ?? identity.domain;
   const cwd = options.cwd ?? processCwd();
   await setCwd(cwd);
-  const tools = options.tools ?? await loadGatewayTools(domainId);
-  const [systemPrompt, context] = await Promise.all([
-    getSystemPrompt({ domain: domainId }),
-    getContext()
-  ]);
   const userMessage = createUserMessage(options.prompt);
   const messages = [...options.sessionMessages ?? [], userMessage];
+  const messageLogName = `gateway-${Date.now()}`;
+  const [systemPrompt, context, queryOpts, skillMatch] = await Promise.all([
+    getSystemPrompt({ domain: domainId }),
+    getContext(),
+    createQueryOptions({
+      messages,
+      safeMode: options.safeMode,
+      messageLogName,
+      verbose: false,
+      persistSession: false
+    }),
+    matchSkillForPrompt(options.prompt)
+  ]);
+  if (skillMatch) {
+    systemPrompt.unshift(buildSkillMatchDirective(skillMatch));
+  }
   const abortController = new AbortController();
   const seenToolUseIds = /* @__PURE__ */ new Set();
+  const toolTrace = [];
+  const reasoningEvents = [];
+  let modelName = "unknown";
+  try {
+    const { getModelManager } = await import("./model-FUBCTRTV.js");
+    const manager = getModelManager();
+    modelName = manager.getModelName("main") ?? "unknown";
+  } catch {
+  }
+  yield {
+    type: "status",
+    content: JSON.stringify({
+      model: modelName,
+      state: "started",
+      iteration: 0,
+      timestamp: Date.now()
+    })
+  };
+  let iterationCount = 0;
+  let totalInputTokens = 0;
+  let totalOutputTokens = 0;
+  let totalCacheReadTokens = 0;
+  let totalCacheCreationTokens = 0;
   for await (const msg of query(
     messages,
     systemPrompt,
     context,
     gatewayPermissionHandler,
     {
-      options: {
-        commands: [],
-        tools,
-        verbose: false,
-        safeMode: options.safeMode ?? false,
-        forkNumber: 0,
-        messageLogName: `gateway-${Date.now()}`,
-        maxThinkingTokens: 0,
-        persistSession: false,
-        shouldAvoidPermissionPrompts: true
-      },
+      ...queryOpts,
       abortController,
-      messageId: void 0,
-      readFileTimestamps: {},
-      setToolJSX: () => {
-      }
+      reasoningEvents
     }
   )) {
+    while (reasoningEvents.length > 0) {
+      const event = reasoningEvents.shift();
+      yield { type: "reasoning", content: JSON.stringify(event) };
+    }
     if (msg.type === "assistant") {
+      iterationCount++;
+      const usage = msg.message.usage;
+      if (usage) {
+        const input = usage.input_tokens ?? 0;
+        const output = usage.output_tokens ?? 0;
+        const cacheRead = usage.cache_read_input_tokens ?? 0;
+        const cacheCreation = usage.cache_creation_input_tokens ?? 0;
+        totalInputTokens += input;
+        totalOutputTokens += output;
+        totalCacheReadTokens += cacheRead;
+        totalCacheCreationTokens += cacheCreation;
+        yield {
+          type: "usage",
+          content: JSON.stringify({
+            inputTokens: input,
+            outputTokens: output,
+            cacheReadTokens: cacheRead,
+            cacheCreationTokens: cacheCreation,
+            totalInputTokens,
+            totalOutputTokens,
+            totalCacheReadTokens,
+            totalCacheCreationTokens,
+            costUSD: msg.costUSD ?? 0,
+            iteration: iterationCount
+          })
+        };
+      }
+      yield {
+        type: "status",
+        content: JSON.stringify({
+          model: modelName,
+          state: "thinking",
+          iteration: iterationCount,
+          toolCallCount: toolTrace.length,
+          timestamp: Date.now()
+        })
+      };
       for (const block of msg.message.content) {
         if (block.type === "text" && block.text) {
           yield { type: "text", content: block.text };
@@ -177,6 +256,7 @@ async function* gatewayQueryStream(options) {
         } else if (block.type === "tool_use") {
           seenToolUseIds.add(block.id);
           const inputBrief = JSON.stringify(block.input).slice(0, 200);
+          toolTrace.push({ name: block.name, input: inputBrief, succeeded: true });
           yield { type: "tool_call", content: `${block.name}(${inputBrief})` };
         }
       }
@@ -185,6 +265,7 @@ async function* gatewayQueryStream(options) {
         if (block.type === "tool_use" && !seenToolUseIds.has(block.id)) {
           seenToolUseIds.add(block.id);
           const inputBrief = JSON.stringify(block.input).slice(0, 200);
+          toolTrace.push({ name: block.name, input: inputBrief, succeeded: true });
           yield { type: "tool_call", content: `${block.name}(${inputBrief})` };
         }
       }
@@ -194,12 +275,43 @@ async function* gatewayQueryStream(options) {
         for (const block of content) {
           if (block.type === "tool_result") {
             const raw = typeof block.content === "string" ? block.content : JSON.stringify(block.content);
+            const isError = block.is_error === true || raw.includes("error") || raw.includes("Error") || raw.includes("REDIRECT");
+            if (isError && toolTrace.length > 0) {
+              toolTrace[toolTrace.length - 1].succeeded = false;
+            }
             yield { type: "tool_result", content: raw.slice(0, 500) };
           }
         }
       }
     }
   }
+  while (reasoningEvents.length > 0) {
+    const event = reasoningEvents.shift();
+    yield { type: "reasoning", content: JSON.stringify(event) };
+  }
+  if (toolTrace.length > 0) {
+    const steps = toolTrace.map((t, i) => {
+      const status = t.succeeded ? "\u2713" : "\u2717";
+      return `${i + 1}. ${status} ${t.name}`;
+    });
+    const summary = `
+
+---
+**\u83B7\u53D6\u8DEF\u5F84**: ${steps.join(" \u2192 ")}`;
+    yield { type: "text", content: summary };
+  }
+  yield {
+    type: "status",
+    content: JSON.stringify({
+      model: modelName,
+      state: "completed",
+      iteration: iterationCount,
+      toolCallCount: toolTrace.length,
+      totalInputTokens,
+      totalOutputTokens,
+      timestamp: Date.now()
+    })
+  };
   yield { type: "done", content: "" };
 }
 
@@ -274,9 +386,137 @@ function maxConcurrencyMiddleware(options = {}) {
 
 // src/channels/http.ts
 import { createServer } from "http";
-import { randomUUID } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 import { resolve, join, extname } from "path";
 import { readFile, stat } from "fs/promises";
+
+// src/gateway/openaiCompat.ts
+import { randomUUID } from "crypto";
+function convertOpenAIRequestToGateway(body, sessionKey) {
+  const messages = body.messages ?? [];
+  let prompt = "";
+  let systemPrompt = "";
+  const systemMessages = messages.filter((m) => m.role === "system");
+  if (systemMessages.length > 0) {
+    systemPrompt = systemMessages.map((m) => m.content ?? "").filter(Boolean).join("\n\n");
+  }
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i].role === "user" && messages[i].content) {
+      prompt = messages[i].content;
+      break;
+    }
+  }
+  const conversationHistory = messages.filter((m) => m.role !== "system");
+  const contextParts = [];
+  if (systemPrompt) {
+    contextParts.push(`<system_context>
+${systemPrompt}
+</system_context>`);
+  }
+  const priorMessages = conversationHistory.slice(0, -1);
+  if (priorMessages.length > 0) {
+    const historyLines = priorMessages.map((m) => {
+      if (m.role === "assistant") {
+        if (m.tool_calls && m.tool_calls.length > 0) {
+          const toolDescs = m.tool_calls.map((tc) => `[tool_call: ${tc.function.name}(${tc.function.arguments})]`).join(" ");
+          return `Assistant: ${m.content ?? ""} ${toolDescs}`;
+        }
+        return `Assistant: ${m.content ?? ""}`;
+      }
+      if (m.role === "tool") {
+        return `Tool(${m.tool_call_id ?? m.name ?? ""}): ${m.content ?? ""}`;
+      }
+      if (m.role === "user") {
+        return `User: ${m.content ?? ""}`;
+      }
+      return "";
+    }).filter(Boolean);
+    if (historyLines.length > 0) {
+      contextParts.push(`<conversation_history>
+${historyLines.join("\n")}
+</conversation_history>`);
+    }
+  }
+  if (body.tools && body.tools.length > 0) {
+    const toolDescriptions = body.tools.map((t) => `- ${t.function.name}: ${t.function.description ?? "(no description)"}`).join("\n");
+    contextParts.push(`<available_tools>
+${toolDescriptions}
+</available_tools>`);
+  }
+  if (contextParts.length > 0 && prompt) {
+    prompt = `${contextParts.join("\n\n")}
+
+${prompt}`;
+  }
+  return {
+    prompt,
+    domain: "coding",
+    safeMode: false,
+    systemPrompt,
+    conversationHistory,
+    openaiTools: body.tools
+  };
+}
+function buildCompletionResponse(model, content) {
+  return {
+    id: `chatcmpl-${randomUUID().replace(/-/g, "").slice(0, 24)}`,
+    object: "chat.completion",
+    created: Math.floor(Date.now() / 1e3),
+    model,
+    choices: [
+      {
+        index: 0,
+        message: {
+          role: "assistant",
+          content
+        },
+        finish_reason: "stop"
+      }
+    ],
+    usage: {
+      prompt_tokens: 0,
+      completion_tokens: 0,
+      total_tokens: 0
+    }
+  };
+}
+function buildChunk(completionId, model, delta, finishReason = null) {
+  return {
+    id: completionId,
+    object: "chat.completion.chunk",
+    created: Math.floor(Date.now() / 1e3),
+    model,
+    choices: [
+      {
+        index: 0,
+        delta,
+        finish_reason: finishReason
+      }
+    ]
+  };
+}
+function buildDoneChunk(completionId, model) {
+  return {
+    id: completionId,
+    object: "chat.completion.chunk",
+    created: Math.floor(Date.now() / 1e3),
+    model,
+    choices: [
+      {
+        index: 0,
+        delta: {},
+        finish_reason: "stop"
+      }
+    ],
+    usage: {
+      prompt_tokens: 0,
+      completion_tokens: 0,
+      total_tokens: 0
+    }
+  };
+}
+
+// src/channels/http.ts
 var MIME_TYPES = {
   ".html": "text/html; charset=utf-8",
   ".js": "application/javascript; charset=utf-8",
@@ -365,6 +605,14 @@ var HttpChannel = class {
       await this.handleChatStream(req, res);
       return;
     }
+    if (req.method === "POST" && (req.url === "/v1/chat/completions" || req.url === "/chat/completions")) {
+      await this.handleOpenAICompat(req, res);
+      return;
+    }
+    if (req.method === "GET" && req.url === "/v1/models") {
+      await this.handleOpenAIModels(req, res);
+      return;
+    }
     if (req.method === "GET" && this.config.webDistDir) {
       const served = await this.serveStatic(req, res);
       if (served) return;
@@ -429,7 +677,7 @@ var HttpChannel = class {
         res.end(JSON.stringify({ error: "No handler registered" }));
         return;
       }
-      const requestId = randomUUID();
+      const requestId = randomUUID2();
       this.pendingResponses.set(requestId, []);
       await this.handler({
         channelId: "http",
@@ -479,7 +727,7 @@ var HttpChannel = class {
         userId,
         sessionKey: sessionKey ?? `http:${userId}`,
         text: message,
-        metadata: { requestId: randomUUID() }
+        metadata: { requestId: randomUUID2() }
       };
       await this.streamHandler(unifiedMsg, res);
     } catch (err) {
@@ -493,6 +741,144 @@ var HttpChannel = class {
       }
     }
   }
+  async handleOpenAICompat(req, res) {
+    if (!this.checkAuth(req, res)) return;
+    try {
+      const raw = await readBody(req);
+      const body = JSON.parse(raw);
+      const model = body.model ?? "kode-agent";
+      const isStream = body.stream === true;
+      const gatewayOpts = convertOpenAIRequestToGateway(body, `openai:${randomUUID2().slice(0, 8)}`);
+      if (!gatewayOpts.prompt) {
+        res.setHeader("Content-Type", "application/json");
+        res.writeHead(400);
+        res.end(JSON.stringify({
+          error: { message: "No user message found in messages array", type: "invalid_request_error", code: "missing_user_message" }
+        }));
+        return;
+      }
+      if (isStream) {
+        res.writeHead(200, {
+          "Content-Type": "text/event-stream",
+          "Cache-Control": "no-cache",
+          "Connection": "keep-alive",
+          "X-Accel-Buffering": "no"
+        });
+        const completionId = `chatcmpl-${randomUUID2().replace(/-/g, "").slice(0, 24)}`;
+        let streamEnded = false;
+        const safeWrite = (data) => {
+          if (streamEnded || res.writableEnded || res.destroyed) return false;
+          try {
+            return res.write(data);
+          } catch {
+            return false;
+          }
+        };
+        safeWrite(`data: ${JSON.stringify(buildChunk(completionId, model, { role: "assistant", content: "" }))}
+
+`);
+        if (this.streamHandler) {
+          const unifiedMsg = {
+            channelId: "http",
+            userId: "openai-compat",
+            sessionKey: `openai:${randomUUID2().slice(0, 8)}`,
+            text: gatewayOpts.prompt,
+            metadata: { requestId: randomUUID2(), openaiCompat: true }
+          };
+          const interceptRes = Object.create(res);
+          interceptRes.write = ((data) => {
+            if (typeof data === "string" && data.startsWith("event:")) {
+              const lines = data.split("\n");
+              for (const line of lines) {
+                if (line.startsWith("data: ")) {
+                  try {
+                    const parsed = JSON.parse(line.slice(6));
+                    if (parsed.type === "text" || parsed.content && typeof parsed.content === "string") {
+                      const textContent = parsed.content ?? parsed.text ?? "";
+                      if (textContent) {
+                        safeWrite(`data: ${JSON.stringify(buildChunk(completionId, model, { content: textContent }))}
+
+`);
+                      }
+                    }
+                  } catch {
+                  }
+                }
+              }
+              return true;
+            }
+            return safeWrite(data);
+          });
+          interceptRes.end = (() => {
+          });
+          await this.streamHandler(unifiedMsg, interceptRes);
+        }
+        safeWrite(`data: ${JSON.stringify(buildDoneChunk(completionId, model))}
+
+`);
+        safeWrite("data: [DONE]\n\n");
+        streamEnded = true;
+        res.end();
+      } else {
+        if (!this.handler) {
+          res.setHeader("Content-Type", "application/json");
+          res.writeHead(503);
+          res.end(JSON.stringify({
+            error: { message: "Service unavailable", type: "server_error" }
+          }));
+          return;
+        }
+        const requestId = randomUUID2();
+        this.pendingResponses.set(requestId, []);
+        await this.handler({
+          channelId: "http",
+          userId: requestId,
+          sessionKey: `openai:${requestId.slice(0, 8)}`,
+          text: gatewayOpts.prompt,
+          metadata: { requestId, openaiCompat: true }
+        });
+        const responses = this.pendingResponses.get(requestId) ?? [];
+        this.pendingResponses.delete(requestId);
+        const textContent = responses.filter((r) => r.type === "text").map((r) => r.content).join("");
+        const completion = buildCompletionResponse(model, textContent);
+        res.setHeader("Content-Type", "application/json");
+        res.writeHead(200);
+        res.end(JSON.stringify(completion));
+      }
+    } catch (err) {
+      if (!res.headersSent) {
+        res.setHeader("Content-Type", "application/json");
+        res.writeHead(500);
+        res.end(JSON.stringify({
+          error: { message: err.message ?? "Internal server error", type: "server_error" }
+        }));
+      } else if (!res.writableEnded && !res.destroyed) {
+        try {
+          res.write(`data: ${JSON.stringify({ error: { message: err.message } })}
+
+`);
+          res.write("data: [DONE]\n\n");
+          res.end();
+        } catch {
+        }
+      }
+    }
+  }
+  async handleOpenAIModels(_req, res) {
+    res.setHeader("Content-Type", "application/json");
+    res.writeHead(200);
+    res.end(JSON.stringify({
+      object: "list",
+      data: [
+        {
+          id: "kode-agent",
+          object: "model",
+          created: Math.floor(Date.now() / 1e3),
+          owned_by: "kode"
+        }
+      ]
+    }));
+  }
 };
 function writeSseEvent(res, event, data) {
   res.write(`event: ${event}
@@ -687,7 +1073,7 @@ var Gateway = class {
 // src/channels/websocket.ts
 import { createServer as createServer2 } from "http";
 import { WebSocketServer } from "ws";
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 var WebSocketChannel = class {
   constructor(config) {
     this.config = config;
@@ -751,7 +1137,7 @@ var WebSocketChannel = class {
         return;
       }
     }
-    const clientId = randomUUID2();
+    const clientId = randomUUID3();
     this.clients.set(clientId, {
       ws,
       userId: clientId,
@@ -979,10 +1365,13 @@ var FileSessionStorage = class {
 };
 
 // src/entrypoints/gateway.ts
+init_config();
 import { join as join3, dirname } from "path";
 import { homedir } from "os";
 import { existsSync as existsSync2 } from "fs";
 import { fileURLToPath } from "url";
+init_log();
+init_sandbox();
 function parseArgs(argv) {
   const opts = {
     port: 3e3,
@@ -1109,6 +1498,15 @@ function resolveWebDir(explicit) {
 }
 async function main() {
   const opts = parseArgs(process.argv);
+  try {
+    enableConfigs();
+  } catch (e) {
+    logError(e);
+  }
+  const config = getGlobalConfig();
+  if (!config.hasCompletedOnboarding) {
+    await showSetupScreens(opts.safeMode);
+  }
   if (opts.name || opts.description) {
     setIdentity({
       ...opts.name ? { name: opts.name } : {},
@@ -1154,11 +1552,59 @@ async function main() {
     const cliChannel = new CliChannel({ prompt: `[${opts.name ?? "NewCraw"}] > ` });
     gateway.registerChannel(cliChannel);
   }
+  const { pool: sandboxPool, capabilities: sandboxCaps } = await tryInitSandboxPool();
+  if (sandboxPool) {
+    console.log(`[Gateway] Container sandbox ready: ${sandboxCaps.name} (${sandboxCaps.version ?? "unknown"})${sandboxCaps.rootless ? " [rootless]" : ""}`);
+  } else {
+    console.log(`[Gateway] Container sandbox not available (bwrap/sandbox-exec fallback active)`);
+  }
+  registerHealthProbe(async (provider) => {
+    try {
+      const { getModelManager } = await import("./model-FUBCTRTV.js");
+      const manager = getModelManager();
+      const profiles = [
+        manager.getModel("main"),
+        manager.getModel("task"),
+        manager.getModel("quick")
+      ].filter(Boolean);
+      const match = profiles.find((p) => p?.provider === provider);
+      if (!match) return true;
+      const OpenAI = (await import("openai")).default;
+      const client = new OpenAI({
+        apiKey: match.apiKey ?? process.env.OPENAI_API_KEY ?? "sk-probe",
+        baseURL: match.baseUrl,
+        timeout: 1e4
+      });
+      await client.models.list();
+      return true;
+    } catch {
+      return false;
+    }
+  });
+  try {
+    const { getModelManager } = await import("./model-FUBCTRTV.js");
+    const manager = getModelManager();
+    const providerSet = /* @__PURE__ */ new Set();
+    for (const role of ["main", "task", "quick"]) {
+      const profile = manager.getModel(role);
+      if (profile && profile.provider) {
+        providerSet.add(profile.provider);
+      }
+    }
+    if (providerSet.size > 0) {
+      startPeriodicHealthCheck([...providerSet]);
+    }
+  } catch {
+  }
   process.on("SIGINT", async () => {
+    stopPeriodicHealthCheck();
+    await shutdownSandboxPool();
     await gateway.stop();
     process.exit(0);
   });
   process.on("SIGTERM", async () => {
+    stopPeriodicHealthCheck();
+    await shutdownSandboxPool();
     await gateway.stop();
     process.exit(0);
   });