surf-cli 2.12.0 → 2.13.0

package/README.md

@@ -490,6 +490,12 @@ surf aistudio "explain quantum computing"
 surf aistudio "redteam this" --with-page                      # Include page context
 surf aistudio "quick answer" --model gemini-3-flash-preview   # Model selection
 
+# Kimi (queries kimi.com - Moonshot K-series - using your browser login)
+surf kimi "explain quantum computing"
+surf kimi "summarize" --with-page                             # Include page context
+surf kimi "quick answer" --model thinking                     # Models: instant (default), thinking, high
+surf kimi --validate                                           # Check kimi.com UI and available models
+
 # AI Studio App Builder (generates full web apps from a prompt)
 surf aistudio.build "build a portfolio site"
 surf aistudio.build "todo app" --model gemini-3.1-pro-preview # Model override

package/native/cli.cjs

@@ -355,6 +355,22 @@ const TOOLS = {
           { cmd: 'aistudio "quick answer" --model gemini-3-flash-preview', desc: "Model selection" },
         ]
       },
+      "kimi": {
+        desc: "Query Kimi AI (kimi.com, Moonshot K-series) using your browser session",
+        args: ["query"],
+        opts: {
+          "with-page": "Include current page context",
+          model: "Model: instant (default), thinking, high - or any model label shown in kimi.com's model picker",
+          timeout: "Timeout in seconds (default: 300)",
+          validate: "Check kimi.com UI and available models (no query sent)"
+        },
+        examples: [
+          { cmd: 'kimi "explain quantum computing"', desc: "Basic query" },
+          { cmd: 'kimi "summarize" --with-page', desc: "With page context" },
+          { cmd: 'kimi "deep dive" --model thinking', desc: "Try the Thinking model" },
+          { cmd: 'kimi --validate', desc: "Check UI and list available models" },
+        ]
+      },
       "aistudio.build": {
         desc: "Build an app via Google AI Studio App Builder (uses browser session)",
         args: ["query"],
@@ -2625,6 +2641,7 @@ const PRIMARY_ARG_MAP = {
   grok: "query",
   aistudio: "query",
   "aistudio.build": "query",
+  kimi: "query",
   navigate: "url",
   go: "url",
   js: "code",
@@ -3311,6 +3328,10 @@ async function handleResponse(response) {
     data = { response: data };
   }
 
+  if (tool === 'kimi' && typeof data === 'string') {
+    data = { response: data };
+  }
+
   if (tool === "page.save" && typeof data?.html === "string") {
     const saveTo = path.resolve(outputPath);
     fs.mkdirSync(path.dirname(saveTo), { recursive: true });
@@ -3530,7 +3551,18 @@ async function handleResponse(response) {
     if (meta.length > 0) {
       console.error(`[${meta.join(" | ")}]`);
     }
-  } else if (tool === "perplexity" && data?.response) {
+      } else if (tool === "kimi" && data?.response) {
+        console.log(data.response);
+        const meta = [];
+        if (data.model) meta.push(data.model);
+        if (data.partial) meta.push("partial");
+        if (Number.isFinite(data.tookMs)) meta.push(`${(data.tookMs / 1000).toFixed(1)}s`);
+        if (meta.length > 0) console.error(`\n[${meta.join(' | ')}]`);
+        if (data.url) console.error(`URL: ${data.url}`);
+        if (data.warnings?.length) {
+          for (const w of data.warnings) console.warn(`Warning: ${w}`);
+        }
+      } else if (tool === "perplexity" && data?.response) {
     console.log(data.response);
     const meta = [];
     if (data.sources) meta.push(`${data.sources} sources`);

package/native/host-helpers.cjs

@@ -77,8 +77,23 @@ function formatToolContent(result, log = () => {}, options = {}) {
     return text(output);
   }
   
-  // Handle Grok validation results
-  if (result.authenticated !== undefined && result.models !== undefined && result.expectedModels !== undefined) {
+      // Handle Kimi validation results (must precede the Grok branch - same field names)
+      if (result.kimiValidate) {
+        let output = "## Kimi Validation Results\n\n";
+        output += `**Authenticated:** ${result.authenticated ? 'Yes' : 'No'}\n`;
+        output += `**Input Field:** ${result.inputFound ? 'Found' : 'Not Found'}\n`;
+        output += `**Send Button:** ${result.sendButtonFound ? 'Found' : 'Not Found'}\n\n`;
+        output += `**Available Models:** ${result.models.length > 0 ? result.models.join(', ') : 'None found'}\n`;
+        output += `**Expected Models:** ${result.expectedModels.join(', ')}\n\n`;
+        if (result.errors && result.errors.length > 0) {
+          output += `**Errors:**\n${result.errors.map(e => `- ${e}`).join('\n')}\n\n`;
+        }
+        output += `*Completed in ${result.tookMs}ms*`;
+        return text(output);
+      }
+
+      // Handle Grok validation results
+      if (result.authenticated !== undefined && result.models !== undefined && result.expectedModels !== undefined) {
     let output = "## Grok Validation Results\n\n";
     output += `**Authenticated:** ${result.authenticated ? 'Yes' : 'No'}\n`;
     output += `**Premium:** ${result.premium ? 'Yes' : 'No'}\n`;
@@ -1200,6 +1215,22 @@ function mapToolToMessage(tool, args, tabId) {
         ...baseMsg,
       };
     }
+        case "kimi":
+          if (a.validate) {
+            return {
+              type: "KIMI_VALIDATE",
+              ...baseMsg
+            };
+          }
+          if (!a.query) throw new Error("query required");
+          return {
+            type: "KIMI_QUERY",
+            query: a.query,
+            model: a.model,
+            withPage: a["with-page"],
+            timeout: a.timeout ? parseInt(a.timeout, 10) * 1000 : 300000,
+            ...baseMsg
+          };
     case "window.new":
       return { 
         type: "WINDOW_NEW", 

package/native/host-sessions.cjs

@@ -22,6 +22,7 @@ const PROVIDER_DEFAULT_TIMEOUT_SECONDS = {
   chatgpt: 2700,
   gemini: 300,
   grok: 300,
+  kimi: 300,
   perplexity: 120,
   "oracle.result": 300,
   "playbook.run": 600,

package/native/host.cjs

@@ -12,6 +12,7 @@ const chatgptClient = require("./chatgpt-client.cjs");
 const geminiClient = require("./gemini-client.cjs");
 const perplexityClient = require("./perplexity-client.cjs");
 const grokClient = require("./grok-client.cjs");
+const kimiClient = require("./kimi-client.cjs");
 const aistudioClient = require("./aistudio-client.cjs");
 const aistudioBuild = require("./aistudio-build.cjs");
 const { mapToolToMessage, mapComputerAction, formatToolContent, formatToolError, buildProviderUploadMessage } = require("./host-helpers.cjs");
@@ -1237,13 +1238,115 @@ function handleToolRequest(msg, socket, requestContext = requestStorage.getStore
       }
       sendToolResponse(socket, originalId, result, null);
     }).catch((err) => {
-      sendToolResponse(socket, originalId, null, err.message);
-    });
-    
-    return;
-  }
+          sendToolResponse(socket, originalId, null, err.message);
+        });
+
+        return;
+      }
+
+      if (extensionMsg.type === "KIMI_QUERY") {
+        const { query, model, withPage, timeout } = extensionMsg;
+
+        queueAiRequest(async () => {
+          // 1. Get page context if requested
+          let pageContext = null;
+          if (withPage) {
+            const pageResult = await requestCallExtension(
+              requestContext,
+              "get_page_text",
+              { type: "GET_PAGE_TEXT", tabId: extensionMsg.tabId },
+              45000,
+            );
+            if (pageResult && !pageResult.error) {
+              pageContext = {
+                url: pageResult.url,
+                text: pageResult.text || pageResult.pageContent || ""
+              };
+            }
+          }
+
+          // 2. Build full prompt
+          let fullPrompt = query || "";
+          if (pageContext) {
+            fullPrompt = `Page: ${pageContext.url}\n\n${pageContext.text}\n\n---\n\n${fullPrompt}`;
+          }
+
+          // 3. Call Kimi client (uses generic browser primitives, no provider CDP types)
+          const result = await kimiClient.query({
+            prompt: fullPrompt,
+            extractionPrompt: query,
+            signal: requestContext.signal,
+            model: model,
+            timeout: timeout || 300000,
+            createTab: () => requestCallExtension(
+              requestContext,
+              "create_tab",
+              { type: "NEW_TAB", url: "https://www.kimi.com/" },
+            ),
+            closeTab: (tabIdToClose) => requestCallExtension(requestContext, "close_tab", { type: "CLOSE_TAB", tabId: tabIdToClose }, 45000, true),
+            jsEval: (tabId, code) => requestCallExtension(
+              requestContext,
+              "js_eval",
+              { type: "EXECUTE_JAVASCRIPT", tabId, code },
+            ),
+            log: (msg) => log(`[kimi] ${msg}`)
+          });
+
+          return result;
+        }).then((result) => {
+          const response = {
+            response: result.response,
+            model: result.model,
+            tookMs: result.tookMs
+          };
+          if (result.partial) {
+            response.partial = true;
+          }
+          if (result.warnings && result.warnings.length > 0) {
+            response.warnings = result.warnings;
+          }
+          if (result.modelSelectionFailed) {
+            response.modelSelectionFailed = true;
+          }
+          if (result.url) {
+            response.url = result.url;
+          }
+          sendToolResponse(socket, originalId, response, null);
+        }).catch((err) => {
+          sendToolResponse(socket, originalId, null, err.message);
+        });
+
+        return;
+      }
+
+      if (extensionMsg.type === "KIMI_VALIDATE") {
+        queueAiRequest(async () => {
+          const result = await kimiClient.validate({
+            signal: requestContext.signal,
+            createTab: () => requestCallExtension(
+              requestContext,
+              "create_tab",
+              { type: "NEW_TAB", url: "https://www.kimi.com/" },
+            ),
+            closeTab: (tabIdToClose) => requestCallExtension(requestContext, "close_tab", { type: "CLOSE_TAB", tabId: tabIdToClose }, 45000, true),
+            jsEval: (tabId, code) => requestCallExtension(
+              requestContext,
+              "js_eval",
+              { type: "EXECUTE_JAVASCRIPT", tabId, code },
+            ),
+            log: (msg) => log(`[kimi] ${msg}`)
+          });
+          return result;
+        }).then((result) => {
+          sendToolResponse(socket, originalId, result, null);
+        }).catch((err) => {
+          sendToolResponse(socket, originalId, null, err.message);
+        });
+
+        return;
+      }
 
-  if (extensionMsg.type === "AISTUDIO_QUERY") {
+      if (extensionMsg.type === "AISTUDIO_QUERY") {
     const { query, model, withPage, timeout } = extensionMsg;
     
     queueAiRequest(async () => {