skyloom 1.24.0 → 1.26.0

package/src/tools/computer.ts

@@ -5,11 +5,11 @@
  * processes and services, and install/uninstall software.
  */
 
-import { execSync, execFileSync, spawn } from 'child_process';
+import { execSync, execFileSync } from 'child_process';
 import * as os from 'os';
 import * as fs from 'fs';
 import * as path from 'path';
-import type { ToolRegistry, ToolDefinition } from '../core/tool';
+import type { ToolRegistry } from '../core/tool';
 
 const MAX_OUT = 8000;
 

package/src/web/server.ts

@@ -8,11 +8,8 @@
 
 import { createServer, IncomingMessage, ServerResponse } from "http";
 import { createSystemContext } from "../core/factory";
-import { getLogger } from "../core/logger";
 import { renderInkWashUI, SKYLOOM_FAVICON_SVG } from "./ui";
 
-const log = getLogger("web-server");
-
 /* ──────────────────────────────────────────────
    Server
    ────────────────────────────────────────────── */

package/tests/factory.test.ts

@@ -0,0 +1,56 @@
+import { describe, it, expect, vi } from "vitest";
+import { SystemContext, TaskExecutionResult } from "../src/core/factory";
+import { MessageBus } from "../src/core/bus";
+
+describe("factory · TaskExecutionResult", () => {
+  it("holds the provided fields", () => {
+    const r = new TaskExecutionResult({ id: "t1", agent: "fog", description: "do x", success: true, content: "done" });
+    expect(r).toMatchObject({ id: "t1", agent: "fog", success: true, content: "done" });
+  });
+});
+
+describe("factory · SystemContext", () => {
+  function ctx(overrides: Partial<ConstructorParameters<typeof SystemContext>[0]> = {}) {
+    return new SystemContext({
+      config: { agents: {} } as any,
+      bus: new MessageBus(),
+      llm: {} as any,
+      agentMap: new Map(),
+      toolRegistry: {} as any,
+      ...overrides,
+    });
+  }
+
+  it("stores constructor options with sensible defaults", () => {
+    const c = ctx({ workspacePath: "/ws" });
+    expect(c.workspacePath).toBe("/ws");
+    expect(c.mcp).toBeNull();
+    expect(c.mcpStatus).toEqual([]);
+    expect(c.agentMap.size).toBe(0);
+  });
+
+  it("initAll fires the plugin init hook before agents come up", async () => {
+    const emit = vi.fn().mockResolvedValue(undefined);
+    const c = ctx({ plugins: { emit } as any });
+    await c.initAll();
+    expect(emit).toHaveBeenCalledWith("init", expect.objectContaining({ config: expect.anything() }));
+  });
+
+  it("closeAll closes every agent and tolerates a missing mcp", async () => {
+    const close = vi.fn().mockResolvedValue(undefined);
+    const agents = new Map<string, any>([
+      ["fog", { close }],
+      ["rain", { close }],
+    ]);
+    const c = ctx({ agentMap: agents as any });
+    await c.closeAll();
+    expect(close).toHaveBeenCalledTimes(2);
+  });
+
+  it("closeAll also closes mcp when present", async () => {
+    const closeAll = vi.fn().mockResolvedValue(undefined);
+    const c = ctx({ mcp: { closeAll } as any });
+    await c.closeAll();
+    expect(closeAll).toHaveBeenCalled();
+  });
+});

package/tests/mcp_sse.test.ts

@@ -0,0 +1,112 @@
+/**
+ * MCP SSE transport — integration test against a local mock SSE server.
+ *
+ * Exercises the full handshake: GET event-stream → `endpoint` event →
+ * initialize → tools/list → tools/call, with every response delivered back
+ * over the persistent SSE stream and correlated by JSON-RPC id.
+ */
+import { describe, it, expect, afterEach } from "vitest";
+import * as http from "http";
+import { AddressInfo } from "net";
+import { MCPClient } from "../src/core/mcp";
+
+/**
+ * A minimal MCP-over-SSE server: one event-stream connection, a POST endpoint
+ * that echoes JSON-RPC responses back over that stream.
+ */
+function startMockSSEServer(): Promise<{ url: string; close: () => void }> {
+  let sseRes: http.ServerResponse | null = null;
+
+  const server = http.createServer((req, res) => {
+    if (req.method === "GET") {
+      res.writeHead(200, {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive",
+      });
+      sseRes = res;
+      // Advertise the message endpoint (relative path, resolved by the client).
+      res.write("event: endpoint\ndata: /messages\n\n");
+      return;
+    }
+
+    if (req.method === "POST") {
+      let body = "";
+      req.on("data", (c) => (body += c));
+      req.on("end", () => {
+        res.writeHead(202).end();
+        const msg = JSON.parse(body);
+        if (msg.id === undefined || msg.id === null) return; // notification
+        const reply = (result: unknown) => {
+          sseRes?.write(
+            `event: message\ndata: ${JSON.stringify({ jsonrpc: "2.0", id: msg.id, result })}\n\n`
+          );
+        };
+        if (msg.method === "initialize") {
+          reply({ protocolVersion: "2025-03-26", capabilities: {} });
+        } else if (msg.method === "tools/list") {
+          reply({ tools: [{ name: "echo", description: "echo back" }] });
+        } else if (msg.method === "tools/call") {
+          reply({ content: [{ type: "text", text: `hi ${msg.params.arguments.who}` }] });
+        } else if (msg.method === "ping") {
+          reply({});
+        }
+      });
+      return;
+    }
+
+    res.writeHead(404).end();
+  });
+
+  return new Promise((resolve) => {
+    server.listen(0, "127.0.0.1", () => {
+      const port = (server.address() as AddressInfo).port;
+      resolve({
+        url: `http://127.0.0.1:${port}/sse`,
+        close: () => {
+          sseRes?.end();
+          server.close();
+        },
+      });
+    });
+  });
+}
+
+describe("MCP SSE transport", () => {
+  let mock: { url: string; close: () => void } | null = null;
+  let client: MCPClient | null = null;
+
+  afterEach(async () => {
+    await client?.close();
+    mock?.close();
+    client = null;
+    mock = null;
+  });
+
+  it("completes the endpoint handshake and lists tools", async () => {
+    mock = await startMockSSEServer();
+    client = new MCPClient({ name: "mock", url: mock.url });
+
+    const tools = await client.initialize();
+    expect(tools.map((t) => t.name)).toEqual(["echo"]);
+    expect(client.getToolDefinitions()).toHaveLength(1);
+  });
+
+  it("calls a tool and extracts the text result over the stream", async () => {
+    mock = await startMockSSEServer();
+    client = new MCPClient({ name: "mock", url: mock.url });
+
+    await client.initialize();
+    const result = await client.callTool("echo", { who: "skyloom" });
+    expect(result).toBe("hi skyloom");
+  });
+
+  it("reports healthy after the handshake via an SSE ping round-trip", async () => {
+    mock = await startMockSSEServer();
+    client = new MCPClient({ name: "mock", url: mock.url });
+
+    await client.initialize();
+    const health = await client.healthCheck();
+    expect(health.healthy).toBe(true);
+  });
+});

package/tests/pipelines.test.ts

@@ -0,0 +1,118 @@
+import { describe, it, expect } from "vitest";
+import {
+  matchPipeline,
+  matchAllPipelines,
+  buildTasksFromPipeline,
+  listPipelines,
+  getPipelineByName,
+  validateDAG,
+  topologicalSort,
+  type Task,
+} from "../src/core/pipelines";
+
+function task(id: string, dependsOn: string[] = []): Task {
+  return { id, description: id, assignedTo: "fog", parentId: dependsOn[0] ?? null, dependsOn };
+}
+
+describe("pipelines · matching", () => {
+  it("matches a code-review goal to the code_review pipeline", () => {
+    const p = matchPipeline("帮我审查代码");
+    expect(p?.name).toBe("code_review");
+  });
+
+  it("matches an English review goal", () => {
+    expect(matchPipeline("please review my code")?.name).toBe("code_review");
+  });
+
+  it("returns null for an unmatched / empty goal", () => {
+    expect(matchPipeline("今天天气怎么样")).toBeNull();
+    expect(matchPipeline("")).toBeNull();
+  });
+
+  it("matchAllPipelines returns an array (possibly empty)", () => {
+    expect(Array.isArray(matchAllPipelines("审查代码"))).toBe(true);
+    expect(matchAllPipelines("xyzzy nonsense")).toEqual([]);
+  });
+});
+
+describe("pipelines · introspection", () => {
+  it("lists pipelines with names, triggers and steps", () => {
+    const list = listPipelines();
+    expect(list.length).toBeGreaterThan(0);
+    for (const p of list) {
+      expect(typeof p.name).toBe("string");
+      expect(Array.isArray(p.triggers)).toBe(true);
+      expect(Array.isArray(p.steps)).toBe(true);
+    }
+  });
+
+  it("getPipelineByName round-trips a listed name; unknown → null", () => {
+    const name = listPipelines()[0].name as string;
+    expect(getPipelineByName(name)?.name).toBe(name);
+    expect(getPipelineByName("___nope___")).toBeNull();
+  });
+});
+
+describe("pipelines · materialization", () => {
+  it("builds tasks from a pipeline, substituting {goal}", () => {
+    const p = getPipelineByName("code_review")!;
+    const tasks = buildTasksFromPipeline(p, "登录模块");
+    expect(tasks.length).toBe(p.steps.length);
+    expect(tasks[0].description).toContain("登录模块");
+    expect(tasks[0].metadata?.goal).toBe("登录模块");
+    expect(tasks[0].metadata?.pipeline).toBe("code_review");
+  });
+
+  it("a materialized pipeline is a valid DAG", () => {
+    for (const meta of listPipelines()) {
+      const p = getPipelineByName(meta.name as string)!;
+      const tasks = buildTasksFromPipeline(p, "x");
+      const v = validateDAG(tasks);
+      expect(v.valid, `${meta.name}: ${v.errors.join("; ")}`).toBe(true);
+    }
+  });
+});
+
+describe("pipelines · validateDAG", () => {
+  it("accepts a linear chain", () => {
+    const v = validateDAG([task("1"), task("2", ["1"]), task("3", ["2"])]);
+    expect(v.valid).toBe(true);
+    expect(v.errors).toEqual([]);
+  });
+
+  it("flags a missing dependency", () => {
+    const v = validateDAG([task("2", ["1"])]); // 1 doesn't exist
+    expect(v.valid).toBe(false);
+    expect(v.errors.join(" ")).toMatch(/non-existent/);
+  });
+
+  it("detects a cycle", () => {
+    const v = validateDAG([task("a", ["b"]), task("b", ["a"])]);
+    expect(v.valid).toBe(false);
+    expect(v.errors.join(" ")).toMatch(/[Cc]ycle/);
+  });
+});
+
+describe("pipelines · topologicalSort", () => {
+  it("orders dependencies before dependents", () => {
+    const sorted = topologicalSort([task("3", ["2"]), task("1"), task("2", ["1"])]);
+    const order = sorted.map((t) => t.id);
+    expect(order.indexOf("1")).toBeLessThan(order.indexOf("2"));
+    expect(order.indexOf("2")).toBeLessThan(order.indexOf("3"));
+  });
+
+  it("handles independent tasks (all in-degree 0)", () => {
+    const sorted = topologicalSort([task("a"), task("b"), task("c")]);
+    expect(sorted.map((t) => t.id).sort()).toEqual(["a", "b", "c"]);
+  });
+
+  it("a diamond DAG keeps the root first and the join last", () => {
+    // a → b, a → c, b → d, c → d
+    const sorted = topologicalSort([
+      task("d", ["b", "c"]), task("b", ["a"]), task("c", ["a"]), task("a"),
+    ]);
+    const order = sorted.map((t) => t.id);
+    expect(order[0]).toBe("a");
+    expect(order[order.length - 1]).toBe("d");
+  });
+});

package/tests/skill.test.ts

@@ -4,6 +4,7 @@
 import { describe, it, expect } from 'vitest';
 import * as fs from 'fs';
 import * as path from 'path';
+import * as os from 'os';
 
 describe('Skill', () => {
   it('creates a skill with model override', async () => {
@@ -42,7 +43,7 @@ describe('Skill', () => {
 describe('Skill.fromMarkdown', () => {
   it('loads skill with YAML frontmatter', async () => {
     const { Skill } = await import('../src/core/skill');
-    const tmpDir = fs.mkdtempSync('skill-test-');
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'skill-test-'));
     const mdPath = path.join(tmpDir, 'test.md');
     fs.writeFileSync(mdPath, `---
 name: test_skill
@@ -69,7 +70,7 @@ This is a test skill.
 
   it('supports string path', async () => {
     const { Skill } = await import('../src/core/skill');
-    const tmpDir = fs.mkdtempSync('skill-test-');
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'skill-test-'));
     const mdPath = path.join(tmpDir, 'x.md');
     fs.writeFileSync(mdPath, '---\nname: x\ndescription: x\n---\n\nBody.', 'utf-8');
     const s = Skill.fromMarkdown(mdPath);
@@ -83,7 +84,7 @@ This is a test skill.
 
   it('derives triggers from quoted descriptions', async () => {
     const { Skill } = await import('../src/core/skill');
-    const tmpDir = fs.mkdtempSync('skill-test-');
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'skill-test-'));
     const mdPath = path.join(tmpDir, 'pptx.md');
     fs.writeFileSync(mdPath, `---
 name: pptx
@@ -108,7 +109,7 @@ Body.`, 'utf-8');
 
   it('small body loaded in full', async () => {
     const { Skill } = await import('../src/core/skill');
-    const tmpDir = fs.mkdtempSync('skill-test-');
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'skill-test-'));
     const mdPath = path.join(tmpDir, 'small.md');
     fs.writeFileSync(mdPath, '---\nname: small\ndescription: x\n---\n\n# Small Skill\n\nThis fits inline easily.', 'utf-8');
     const s = Skill.fromMarkdown(mdPath);
@@ -122,7 +123,7 @@ Body.`, 'utf-8');
 
   it('large body truncated to head', async () => {
     const { Skill } = await import('../src/core/skill');
-    const tmpDir = fs.mkdtempSync('skill-test-');
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'skill-test-'));
     const mdPath = path.join(tmpDir, 'big.md');
 
     let body = '# Big Skill\n\n## Quick Reference\nFirst section content.\n\n';

package/skill-test-ty2fOA/test.md

@@ -1,10 +0,0 @@
----
-name: test_skill
-description: A test
-model: claude-sonnet-4-6
-temperature: 0.5
-max_tokens: 8192
----
-
-## Test Skill
-This is a test skill.