skyloom 1.15.4 → 1.16.0

package/src/web/ui.ts

@@ -559,8 +559,9 @@ export function renderInkWashUI(): string {
 <meta name="viewport" content="width=device-width,initial-scale=1.0">
 <meta name="color-scheme" content="light dark">
 <title>水墨气象台 · Skyloom</title>
-<link rel="icon" type="image/svg+xml" href="/favicon.svg">
-<link rel="shortcut icon" href="/favicon.ico">
+<link rel="icon" type="image/svg+xml" sizes="any" href="/favicon.svg?v=1.15.5">
+<link rel="shortcut icon" type="image/svg+xml" href="/favicon.ico?v=1.15.5">
+<link rel="apple-touch-icon" href="/favicon.svg?v=1.15.5">
 <meta name="theme-color" content="#f7f3e9">
 <link rel="preconnect" href="https://fonts.googleapis.com">
 <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>

package/tests/command_args.test.ts

@@ -0,0 +1,115 @@
+import { describe, it, expect } from "vitest";
+import {
+  hasWizard, nextWizardStep, buildCommandLine, filterChoices,
+  type WizardContext, type ArgChoice,
+} from "../src/cli/command_args";
+
+const CTX: WizardContext = {
+  providers: [
+    { id: "openai", label: "OpenAI", configured: true, envVar: "OPENAI_API_KEY" },
+    { id: "deepseek", label: "DeepSeek", configured: false, envVar: "DEEPSEEK_API_KEY" },
+    { id: "ollama", label: "Ollama", configured: true },
+  ],
+  models: [
+    { id: "gpt-4o", provider: "openai", label: "gpt-4o", hint: "$2.5/$10" },
+    { id: "deepseek-chat", provider: "deepseek", label: "deepseek-chat", hint: "$0.3/$1.1" },
+  ],
+  sessions: [
+    { id: "abcdef123456", label: "重构搜索模块" },
+    { id: "ff00aa221133", label: "写测试" },
+  ],
+};
+
+describe("hasWizard", () => {
+  it("recognizes wizard commands with or without slash", () => {
+    for (const c of ["model", "/model", "apikey", "/apikey", "connect", "resume"]) {
+      expect(hasWizard(c), c).toBe(true);
+    }
+  });
+  it("rejects non-wizard commands", () => {
+    for (const c of ["help", "/status", "fog", "/clear", "verify"]) {
+      expect(hasWizard(c), c).toBe(false);
+    }
+  });
+});
+
+describe("nextWizardStep · /apikey (the key-config flow)", () => {
+  it("step 0 lists providers with configured badges", () => {
+    const step = nextWizardStep("/apikey", [], CTX)!;
+    expect(step.kind).toBe("choice");
+    expect(step.choices.map((c) => c.value)).toEqual(["openai", "deepseek", "ollama"]);
+    expect(step.choices[0].hint).toContain("已配置");      // openai configured
+    expect(step.choices[1].hint).toContain("DEEPSEEK_API_KEY"); // deepseek not configured
+    expect(step.allowFreeform).toBe(true);
+  });
+  it("step 1 prompts for the key, masked", () => {
+    const step = nextWizardStep("/apikey", ["deepseek"], CTX)!;
+    expect(step.kind).toBe("freeform");
+    expect(step.secret).toBe(true);
+    expect(step.title).toContain("deepseek");
+  });
+  it("is complete after provider + key", () => {
+    expect(nextWizardStep("/apikey", ["deepseek", "sk-xxx"], CTX)).toBeNull();
+  });
+  it("builds the correct command line", () => {
+    expect(buildCommandLine("/apikey", ["deepseek", "sk-xxx"])).toBe("/apikey set deepseek sk-xxx");
+  });
+});
+
+describe("nextWizardStep · /model", () => {
+  it("offers reset + every model, completes after one pick", () => {
+    const step = nextWizardStep("/model", [], CTX)!;
+    expect(step.choices[0].value).toBe("reset");
+    expect(step.choices.map((c) => c.value)).toContain("gpt-4o");
+    expect(step.choices.find((c) => c.value === "gpt-4o")!.group).toBe("openai");
+    expect(nextWizardStep("/model", ["gpt-4o"], CTX)).toBeNull();
+  });
+  it("builds /model <id> and /model reset", () => {
+    expect(buildCommandLine("/model", ["gpt-4o"])).toBe("/model gpt-4o");
+    expect(buildCommandLine("/model", ["reset"])).toBe("/model reset");
+  });
+});
+
+describe("nextWizardStep · /connect and /resume", () => {
+  it("connect picks a provider", () => {
+    const step = nextWizardStep("/connect", [], CTX)!;
+    expect(step.choices.map((c) => c.value)).toEqual(["openai", "deepseek", "ollama"]);
+    expect(nextWizardStep("/connect", ["openai"], CTX)).toBeNull();
+    expect(buildCommandLine("/connect", ["openai"])).toBe("/connect openai");
+  });
+  it("resume lists sessions by index, builds /resume <n>", () => {
+    const step = nextWizardStep("/resume", [], CTX)!;
+    expect(step.choices.map((c) => c.value)).toEqual(["1", "2"]);
+    expect(step.choices[0].label).toContain("重构搜索模块");
+    expect(buildCommandLine("/resume", ["1"])).toBe("/resume 1");
+  });
+  it("resume with no sessions still returns a (empty) step, not a crash", () => {
+    const step = nextWizardStep("/resume", [], { ...CTX, sessions: [] })!;
+    expect(step.choices).toHaveLength(0);
+    expect(step.allowFreeform).toBe(true);
+  });
+});
+
+describe("filterChoices", () => {
+  const choices: ArgChoice[] = [
+    { value: "gpt-4o", label: "gpt-4o", group: "openai" },
+    { value: "deepseek-chat", label: "deepseek-chat", group: "deepseek" },
+    { value: "gpt-4o-mini", label: "gpt-4o-mini", group: "openai" },
+  ];
+  it("returns all on empty query", () => {
+    expect(filterChoices(choices, "")).toHaveLength(3);
+  });
+  it("matches on value substring", () => {
+    expect(filterChoices(choices, "deepseek").map((c) => c.value)).toEqual(["deepseek-chat"]);
+  });
+  it("matches on group", () => {
+    expect(filterChoices(choices, "openai").map((c) => c.value).sort()).toEqual(["gpt-4o", "gpt-4o-mini"]);
+  });
+  it("ranks exact/prefix matches before substring matches", () => {
+    const ranked = filterChoices(choices, "gpt-4o");
+    expect(ranked[0].value).toBe("gpt-4o"); // exact first
+  });
+  it("returns empty when nothing matches", () => {
+    expect(filterChoices(choices, "zzz")).toHaveLength(0);
+  });
+});

package/tests/loom.test.ts

@@ -247,6 +247,80 @@ describe("palette ↑↓ navigation + Enter execution", () => {
   });
 });
 
+describe("argument wizard (cascading ↑↓ selection)", () => {
+  function key(ui: any, name: string, opts: Record<string, any> = {}) { ui.onKey(opts.str ?? "", { name, ...opts }); }
+  function type(ui: any, text: string) { for (const ch of text) ui.onKey(ch, { name: ch }); }
+
+  // A two-level /apikey wizard: pick a provider, then paste a key.
+  function wireApikeyWizard(ui: any) {
+    ui.wizardStep = (command: string, prior: string[]) => {
+      if (!/apikey/.test(command)) return null;
+      if (prior.length === 0) return {
+        kind: "choice", title: "选择 Provider", allowFreeform: true,
+        choices: [
+          { value: "deepseek", label: "DeepSeek", hint: "未配置" },
+          { value: "openai", label: "OpenAI", hint: "✓ 已配置" },
+        ],
+      };
+      if (prior.length === 1) return { kind: "freeform", title: `粘贴 ${prior[0]} key`, choices: [], allowFreeform: true, secret: true };
+      return null;
+    };
+  }
+
+  it("selecting a wizard command opens the wizard and cascades to submit", async () => {
+    const ui = makeUI() as any;
+    wireApikeyWizard(ui);
+    const p = ui.readInput();
+    type(ui, "/apikey");
+    key(ui, "return");          // palette → opens the wizard (input cleared, not submitted)
+    expect(ui.inputGlyphs.length).toBe(0);
+
+    key(ui, "down");            // deepseek → openai
+    key(ui, "return");          // pick provider → advance to the key step
+    type(ui, "sk-secret");
+    key(ui, "return");          // submit
+
+    expect(await p).toBe("/apikey set openai sk-secret");
+  });
+
+  it("typing filters the choice list; Enter picks the filtered match", async () => {
+    const ui = makeUI() as any;
+    wireApikeyWizard(ui);
+    const p = ui.readInput();
+    type(ui, "/apikey");
+    key(ui, "return");
+    type(ui, "deep");          // filters to deepseek
+    key(ui, "return");         // pick it
+    type(ui, "k1");
+    key(ui, "return");
+    expect(await p).toBe("/apikey set deepseek k1");
+  });
+
+  it("backspace at an empty filter steps back a level; Esc cancels", async () => {
+    const ui = makeUI() as any;
+    wireApikeyWizard(ui);
+    ui.readInput();
+    type(ui, "/apikey");
+    key(ui, "return");         // wizard open at provider step
+    key(ui, "return");         // pick deepseek → key step
+    key(ui, "backspace");      // empty typed → back to provider step
+    // still in the wizard, not submitted; Esc closes it entirely
+    key(ui, "escape");
+    expect(ui.inputGlyphs.length).toBe(0);
+    // a frame still renders at full width after cancelling
+    for (const row of ui.paint()) expect(visualWidth(row)).toBe(80);
+  });
+
+  it("a non-wizard command is unaffected (submits directly)", async () => {
+    const ui = makeUI() as any;
+    wireApikeyWizard(ui);                 // only /apikey has a wizard
+    const p = ui.readInput();
+    type(ui, "/status");
+    key(ui, "return");
+    expect(await p).toBe("/status");
+  });
+});
+
 describe("mouse wheel scrolling", () => {
   // Replay an SGR mouse sequence the way Node's keypress parser fragments it:
   // ESC[< as one event, then every remaining char separately.

package/tests/tool_router.test.ts

@@ -53,6 +53,21 @@ describe('selectRelevantTools', () => {
     expect(selected).toContain('read_file');
   });
 
+  it('surfaces web_search for current-events queries among many tools', () => {
+    // Regression: "今日热点新闻" used to score 0 for web_search, so with a large
+    // tool catalog it never made the shortlist and the LLM couldn't use it.
+    const r = makeRegistry([
+      ['web_search', 'search the live web'],
+      ['read_url', 'read a web page as text'],
+      ...Array.from({ length: 30 }, (_, i): [string, string] => [`tool_${i}`, `unrelated capability ${i}`]),
+    ]);
+    const names = r.listNames();
+    for (const q of ['今日热点新闻', '最新的事件', "today's latest news", '查一下现在的天气']) {
+      const selected = selectRelevantTools(r, names, q, { topK: 8 });
+      expect(selected, `query: ${q}`).toContain('web_search');
+    }
+  });
+
   it('mustInclude always present', () => {
     const r = makeRegistry(Array.from({ length: 20 }, (_, i) => [`random_${i}`, `unrelated tool ${i}`]));
     r.register({

package/tests/web.test.ts

@@ -138,16 +138,18 @@ describe("web · server", () => {
     const body = await page.text();
     expect(body).toContain("水墨气象台");
     expect(body).toContain("clientMain()");
-    expect(body).toContain('href="/favicon.svg"');
+    expect(body).toContain('href="/favicon.svg?v=');
+    expect(body).toContain('href="/favicon.ico?v=');
 
-    const icon = await fetch(`http://127.0.0.1:${port}/favicon.svg`);
+    const icon = await fetch(`http://127.0.0.1:${port}/favicon.svg?v=test`);
     expect(icon.status).toBe(200);
     expect(icon.headers.get("content-type")).toContain("image/svg+xml");
+    expect(icon.headers.get("cache-control")).toContain("no-cache");
     expect(await icon.text()).toContain("<svg");
 
-    const legacyIcon = await fetch(`http://127.0.0.1:${port}/favicon.ico`, { redirect: "manual" });
-    expect(legacyIcon.status).toBe(302);
-    expect(legacyIcon.headers.get("location")).toBe("/favicon.svg");
+    const legacyIcon = await fetch(`http://127.0.0.1:${port}/favicon.ico?v=test`, { redirect: "manual" });
+    expect(legacyIcon.status).toBe(200);
+    expect(legacyIcon.headers.get("content-type")).toContain("image/svg+xml");
 
     const agents = await fetch(`http://127.0.0.1:${port}/api/agents`);
     expect(agents.status).toBe(200);

package/tests/websearch.test.ts

@@ -0,0 +1,190 @@
+import { describe, it, expect } from "vitest";
+import {
+  webSearch, resolveProviders, formatSearchResults, readPage,
+  type WebHttp, type EnvMap,
+} from "../src/tools/websearch";
+
+/** A scriptable HTTP stub: match by URL substring, record calls. */
+function stubHttp(routes: { match: string; json?: any; text?: string; throws?: string }[]): WebHttp & { calls: string[] } {
+  const calls: string[] = [];
+  const pick = (url: string) => routes.find((r) => url.includes(r.match));
+  const run = (url: string) => {
+    calls.push(url);
+    const r = pick(url);
+    if (!r) throw new Error("no route for " + url);
+    if (r.throws) throw new Error(r.throws);
+    return r;
+  };
+  return {
+    calls,
+    async getJson(url) { const r = run(url); return r.json; },
+    async postJson(url) { const r = run(url); return r.json; },
+    async getText(url) { const r = run(url); return r.text ?? ""; },
+  };
+}
+
+describe("websearch · provider resolution", () => {
+  it("auto order with no keys: jina first, then scrape engines", () => {
+    const ids = resolveProviders({}).map((p) => p.id);
+    expect(ids[0]).toBe("jina");
+    expect(ids).toContain("duckduckgo");
+    expect(ids.indexOf("jina")).toBeLessThan(ids.indexOf("duckduckgo"));
+  });
+
+  it("prefers keyed providers over jina, in priority order", () => {
+    const ids = resolveProviders({ TAVILY_API_KEY: "k", BRAVE_API_KEY: "k" }).map((p) => p.id);
+    expect(ids[0]).toBe("tavily");
+    expect(ids[1]).toBe("brave");
+    expect(ids.indexOf("tavily")).toBeLessThan(ids.indexOf("jina"));
+  });
+
+  it("a pinned engine restricts to that provider only", () => {
+    expect(resolveProviders({}, "duckduckgo").map((p) => p.id)).toEqual(["duckduckgo"]);
+    expect(resolveProviders({ TAVILY_API_KEY: "k" }, "tavily").map((p) => p.id)).toEqual(["tavily"]);
+    // pinned but key missing → empty (caller reports no results)
+    expect(resolveProviders({}, "tavily")).toHaveLength(0);
+  });
+});
+
+describe("websearch · provider parsers", () => {
+  it("parses Tavily results + answer", async () => {
+    const http = stubHttp([{ match: "api.tavily.com", json: {
+      answer: "42 is the answer",
+      results: [{ title: "T1", url: "https://a.com", content: "snip a" }],
+    } }]);
+    const res = await webSearch("q", { env: { TAVILY_API_KEY: "k" }, http });
+    expect(res.provider).toBe("tavily");
+    expect(res.answer).toBe("42 is the answer");
+    expect(res.results[0]).toEqual({ title: "T1", url: "https://a.com", snippet: "snip a" });
+  });
+
+  it("parses Brave results", async () => {
+    const http = stubHttp([{ match: "api.search.brave.com", json: {
+      web: { results: [{ title: "B1", url: "https://b.com", description: "desc b" }] },
+    } }]);
+    const res = await webSearch("q", { env: { BRAVE_API_KEY: "k" }, http });
+    expect(res.provider).toBe("brave");
+    expect(res.results[0].snippet).toBe("desc b");
+  });
+
+  it("parses Serper organic + answerBox", async () => {
+    const http = stubHttp([{ match: "google.serper.dev", json: {
+      answerBox: { answer: "direct" },
+      organic: [{ title: "S1", link: "https://s.com", snippet: "snip s" }],
+    } }]);
+    const res = await webSearch("q", { env: { SERPER_API_KEY: "k" }, http });
+    expect(res.provider).toBe("serper");
+    expect(res.answer).toBe("direct");
+    expect(res.results[0].url).toBe("https://s.com");
+  });
+
+  it("parses SearXNG JSON", async () => {
+    const http = stubHttp([{ match: "/search?q=", json: {
+      results: [{ title: "X1", url: "https://x.com", content: "snip x" }],
+    } }]);
+    const res = await webSearch("q", { env: { SEARXNG_URL: "https://searx.local/" }, http });
+    expect(res.provider).toBe("searxng");
+    expect(res.results[0].title).toBe("X1");
+  });
+
+  it("parses keyless Jina results", async () => {
+    const http = stubHttp([{ match: "s.jina.ai", json: {
+      data: [{ title: "J1", url: "https://j.com", description: "snip j" }],
+    } }]);
+    const res = await webSearch("q", { env: {}, http });
+    expect(res.provider).toBe("jina");
+    expect(res.results[0].url).toBe("https://j.com");
+  });
+
+  it("scrapes DuckDuckGo HTML when pinned", async () => {
+    const html = `<a class="result__a" href="/l/?uddg=https%3A%2F%2Fd.com">DDG Title</a>
+      <a class="result__snippet">ddg snippet</a>`;
+    const http = stubHttp([{ match: "duckduckgo.com", text: html }]);
+    const res = await webSearch("q", { env: {}, http, engine: "duckduckgo" });
+    expect(res.provider).toBe("duckduckgo");
+    expect(res.results[0]).toEqual({ title: "DDG Title", url: "https://d.com", snippet: "ddg snippet" });
+  });
+});
+
+describe("websearch · waterfall", () => {
+  it("falls through a throwing provider to the next", async () => {
+    const errors: string[] = [];
+    const http = stubHttp([
+      { match: "api.tavily.com", throws: "tavily down" },
+      { match: "s.jina.ai", json: { data: [{ title: "J", url: "https://j.com", description: "s" }] } },
+    ]);
+    const res = await webSearch("q", { env: { TAVILY_API_KEY: "k" }, http, onProviderError: (p, e) => errors.push(p + ":" + e) });
+    expect(res.provider).toBe("jina");
+    expect(errors[0]).toContain("tavily");
+    expect(res.tried).toContain("tavily");
+  });
+
+  it("falls through an empty-result provider to the next", async () => {
+    const http = stubHttp([
+      { match: "s.jina.ai", json: { data: [] } },
+      { match: "duckduckgo.com", text: `<a class="result__a" href="https://d.com">D</a><a class="result__snippet">s</a>` },
+    ]);
+    const res = await webSearch("q", { env: {}, http });
+    expect(res.provider).toBe("duckduckgo");
+  });
+
+  it("returns an empty response listing tried providers when all fail", async () => {
+    const http = stubHttp([
+      { match: "s.jina.ai", throws: "x" },
+      { match: "duckduckgo", throws: "x" }, { match: "bing", throws: "x" },
+      { match: "baidu", throws: "x" }, { match: "sogou", throws: "x" },
+    ]);
+    const res = await webSearch("q", { env: {}, http });
+    expect(res.results).toHaveLength(0);
+    expect(res.tried).toEqual(["jina", "duckduckgo", "bing", "baidu", "sogou"]);
+    expect(formatSearchResults(res)).toContain("No search results");
+  });
+
+  it("rejects an empty query", async () => {
+    await expect(webSearch("   ", {})).rejects.toThrow(/query/);
+  });
+});
+
+describe("websearch · formatting + dedup", () => {
+  it("formats answer and numbered results", () => {
+    const out = formatSearchResults({ provider: "tavily", answer: "A", results: [
+      { title: "T", url: "https://t.com", snippet: "s" },
+    ], tried: ["tavily"] });
+    expect(out).toContain("Answer: A");
+    expect(out).toContain("1. T");
+    expect(out).toContain("https://t.com");
+  });
+
+  it("dedupes by URL and drops non-http entries", async () => {
+    const http = stubHttp([{ match: "s.jina.ai", json: { data: [
+      { title: "A", url: "https://dup.com", description: "1" },
+      { title: "B", url: "https://dup.com", description: "2" }, // duplicate URL
+      { title: "C", url: "javascript:alert(1)", description: "3" }, // non-http
+    ] } }]);
+    const res = await webSearch("q", { env: {}, http });
+    expect(res.results).toHaveLength(1);
+    expect(res.results[0].url).toBe("https://dup.com");
+  });
+});
+
+describe("websearch · readPage", () => {
+  it("uses the Jina reader and clips long output", async () => {
+    const http = stubHttp([{ match: "r.jina.ai", text: "X".repeat(50) }]);
+    const out = await readPage("https://news.com/article", { env: {}, http, maxChars: 10 });
+    expect(http.calls[0]).toContain("r.jina.ai");
+    expect(out).toContain("truncated");
+  });
+
+  it("falls back to a raw fetch when the reader fails", async () => {
+    const http = stubHttp([
+      { match: "r.jina.ai", throws: "reader down" },
+      { match: "raw.com", text: "<html><body>hello <b>world</b></body></html>" },
+    ]);
+    const out = await readPage("https://raw.com/p", { env: {}, http });
+    expect(out).toContain("hello world");
+  });
+
+  it("rejects a non-http url", async () => {
+    await expect(readPage("ftp://x", {})).rejects.toThrow(/http/);
+  });
+});