skyloom 1.16.2 → 1.17.0

package/tests/bgproc.test.ts

@@ -0,0 +1,65 @@
+import { describe, it, expect } from "vitest";
+import { getBackgroundManager } from "../src/core/bgproc";
+
+const NODE = `"${process.execPath}"`;
+
+async function waitFor(pred: () => boolean, timeoutMs = 5000): Promise<boolean> {
+  const t0 = Date.now();
+  while (Date.now() - t0 < timeoutMs) {
+    if (pred()) return true;
+    await new Promise((r) => setTimeout(r, 25));
+  }
+  return pred();
+}
+
+describe("bgproc · background process manager", () => {
+  it("runs a command to completion and captures its output", async () => {
+    const mgr = getBackgroundManager();
+    const { id, error } = mgr.start(`${NODE} -e "process.stdout.write('BGHELLO')"`);
+    expect(error).toBeUndefined();
+    expect(id).toBeTruthy();
+
+    const done = await waitFor(() => mgr.get(id!)?.status !== "running");
+    expect(done).toBe(true);
+    await new Promise((r) => setTimeout(r, 50)); // let final stdout flush
+
+    const r = mgr.read(id!);
+    expect(r.ok).toBe(true);
+    expect(r.text).toContain("BGHELLO");
+    expect(mgr.get(id!)?.status).toBe("exited");
+  });
+
+  it("incremental read advances the cursor (second read is empty)", async () => {
+    const mgr = getBackgroundManager();
+    const { id } = mgr.start(`${NODE} -e "process.stdout.write('ONCE')"`);
+    await waitFor(() => mgr.get(id!)?.status !== "running");
+    await new Promise((r) => setTimeout(r, 50));
+    expect(mgr.read(id!).text).toContain("ONCE");
+    expect(mgr.read(id!).text).toBe(""); // already consumed
+  });
+
+  it("lists jobs and kills a long-running one", async () => {
+    const mgr = getBackgroundManager();
+    const { id } = mgr.start(`${NODE} -e "setInterval(()=>{},1000)"`);
+    expect(mgr.list().some((j) => j.id === id)).toBe(true);
+    expect(mgr.get(id!)?.status).toBe("running");
+
+    const k = mgr.kill(id!);
+    expect(k.ok).toBe(true);
+    const killed = await waitFor(() => mgr.get(id!)?.status === "killed");
+    expect(killed).toBe(true);
+  });
+
+  it("blocks red-line commands before spawning", () => {
+    const mgr = getBackgroundManager();
+    const { id, error } = mgr.start("rm -rf /");
+    expect(id).toBeUndefined();
+    expect(error).toMatch(/BLOCKED|REDLINE/);
+  });
+
+  it("errors on read/kill of an unknown job", () => {
+    const mgr = getBackgroundManager();
+    expect(mgr.read("nope").ok).toBe(false);
+    expect(mgr.kill("nope").ok).toBe(false);
+  });
+});

package/tests/diagnostics.test.ts

@@ -0,0 +1,86 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import {
+  getDiagnostics,
+  getTypeScriptDiagnostics,
+  parseDiagnosticOutput,
+  formatDiagnostics,
+} from "../src/core/diagnostics";
+
+describe("diagnostics · TypeScript compiler API", () => {
+  let dir: string;
+  beforeEach(() => { dir = fs.mkdtempSync(path.join(os.tmpdir(), "sky-diag-")); });
+  afterEach(() => { try { fs.rmSync(dir, { recursive: true, force: true }); } catch {} });
+
+  function write(name: string, content: string): string {
+    const p = path.join(dir, name);
+    fs.writeFileSync(p, content);
+    return p;
+  }
+
+  it("reports a type error with line:col and TS code", () => {
+    const p = write("bad.ts", "const x: number = 'hello';\n");
+    const res = getTypeScriptDiagnostics(p);
+    expect(Array.isArray(res)).toBe(true);
+    const diags = res as any[];
+    expect(diags.length).toBeGreaterThan(0);
+    const err = diags[0];
+    expect(err.severity).toBe("error");
+    expect(err.line).toBe(1);
+    expect(err.code).toMatch(/^TS\d+/);
+    expect(err.source).toBe("ts");
+  });
+
+  it("returns an empty array for a clean file", () => {
+    const p = write("ok.ts", "export const y: number = 5;\n");
+    const res = getTypeScriptDiagnostics(p);
+    expect(Array.isArray(res)).toBe(true);
+    expect((res as any[]).length).toBe(0);
+  });
+
+  it("getDiagnostics dispatches TS files to the compiler API", () => {
+    const p = write("d.ts", "let n: string = 42;\n");
+    const res = getDiagnostics(p, {});
+    expect(Array.isArray(res)).toBe(true);
+    expect((res as any[]).length).toBeGreaterThan(0);
+  });
+
+  it("returns unavailable for an unconfigured non-TS extension", () => {
+    const p = write("script.rb", "puts 'hi'\n");
+    const res = getDiagnostics(p, {});
+    expect(Array.isArray(res)).toBe(false);
+    expect((res as any).unavailable).toContain("no diagnostics provider");
+  });
+
+  it("returns unavailable for a missing file", () => {
+    const res = getDiagnostics(path.join(dir, "nope.ts"), {});
+    expect((res as any).unavailable).toContain("not found");
+  });
+});
+
+describe("diagnostics · external output parsing", () => {
+  it("parses path:line:col: severity message lines", () => {
+    const out = "src/a.py:3:5: error: undefined name 'x'\nsrc/a.py:7:1: warning: unused import";
+    const diags = parseDiagnosticOutput(out, "ruff");
+    expect(diags.length).toBe(2);
+    expect(diags[0]).toMatchObject({ line: 3, column: 5, severity: "error" });
+    expect(diags[1].severity).toBe("warning");
+    expect(diags[0].source).toBe("ruff");
+  });
+});
+
+describe("diagnostics · formatting", () => {
+  it("formats a clean result", () => {
+    expect(formatDiagnostics("a.ts", [])).toContain("no diagnostics");
+  });
+  it("formats errors with counts", () => {
+    const s = formatDiagnostics("a.ts", [
+      { line: 2, column: 3, severity: "error", message: "boom", code: "TS1", source: "ts" },
+    ]);
+    expect(s).toContain("1 error");
+    expect(s).toContain("2:3");
+    expect(s).toContain("boom");
+  });
+});

package/tests/edit_diff.test.ts

@@ -0,0 +1,102 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { unifiedDiff, countOccurrences } from "../src/core/diff";
+import { ToolRegistry } from "../src/core/tool";
+import { registerBuiltinTools } from "../src/tools/builtin";
+
+describe("diff · unifiedDiff", () => {
+  it("returns empty for identical input", () => {
+    const d = unifiedDiff("a\nb\nc", "a\nb\nc");
+    expect(d.text).toBe("");
+    expect(d.stat).toEqual({ added: 0, removed: 0 });
+  });
+
+  it("shows a single changed line with context and a +/- stat", () => {
+    const d = unifiedDiff("a\nb\nc\nd\ne", "a\nb\nX\nd\ne");
+    expect(d.stat).toEqual({ added: 1, removed: 1 });
+    expect(d.text).toContain("-c");
+    expect(d.text).toContain("+X");
+    expect(d.text).toContain(" b"); // context line
+    expect(d.text).toMatch(/@@ -\d+,\d+ \+\d+,\d+ @@/);
+  });
+
+  it("counts added and removed lines for multi-line changes", () => {
+    const d = unifiedDiff("x\n1\n2\ny", "x\n1\n2\n3\ny");
+    expect(d.stat.added).toBe(1);
+    expect(d.stat.removed).toBe(0);
+  });
+});
+
+describe("diff · countOccurrences", () => {
+  it("counts non-overlapping occurrences", () => {
+    expect(countOccurrences("aaaa", "aa")).toBe(2);
+    expect(countOccurrences("abcabc", "abc")).toBe(2);
+    expect(countOccurrences("abc", "z")).toBe(0);
+    expect(countOccurrences("abc", "")).toBe(0);
+  });
+});
+
+describe("edit_file · Claude Code-style semantics", () => {
+  let dir: string;
+  let edit: any;
+  beforeEach(() => {
+    dir = fs.mkdtempSync(path.join(os.tmpdir(), "sky-edit-"));
+    const reg = new ToolRegistry();
+    registerBuiltinTools(reg);
+    edit = reg.get("edit_file")!.handler!;
+  });
+  afterEach(() => { try { fs.rmSync(dir, { recursive: true, force: true }); } catch {} });
+
+  function write(name: string, content: string): string {
+    const p = path.join(dir, name);
+    fs.writeFileSync(p, content);
+    return p;
+  }
+
+  it("replaces a unique match and returns a diff", async () => {
+    const p = write("a.txt", "line1\nfoo\nline3\n");
+    const out = await edit({ path: p, old_text: "foo", new_text: "bar" });
+    expect(out).toContain("Successfully edited");
+    expect(out).toContain("-foo");
+    expect(out).toContain("+bar");
+    expect(fs.readFileSync(p, "utf8")).toBe("line1\nbar\nline3\n");
+  });
+
+  it("refuses an ambiguous edit when old_text is not unique", async () => {
+    const p = write("b.txt", "x\nx\n");
+    const out = await edit({ path: p, old_text: "x", new_text: "y" });
+    expect(out).toContain("appears 2 times");
+    expect(out).toContain("replace_all");
+    // file unchanged
+    expect(fs.readFileSync(p, "utf8")).toBe("x\nx\n");
+  });
+
+  it("replace_all changes every occurrence", async () => {
+    const p = write("c.txt", "x\nx\nx\n");
+    const out = await edit({ path: p, old_text: "x", new_text: "y", replace_all: true });
+    expect(out).toContain("3 occurrences");
+    expect(fs.readFileSync(p, "utf8")).toBe("y\ny\ny\n");
+  });
+
+  it("errors when old_text is missing from the file", async () => {
+    const p = write("d.txt", "hello\n");
+    const out = await edit({ path: p, old_text: "nope", new_text: "x" });
+    expect(out).toContain("not found");
+    expect(fs.readFileSync(p, "utf8")).toBe("hello\n");
+  });
+
+  it("rejects a no-op edit (old_text === new_text)", async () => {
+    const p = write("e.txt", "same\n");
+    const out = await edit({ path: p, old_text: "same", new_text: "same" });
+    expect(out).toContain("identical");
+  });
+
+  it("treats $-patterns in new_text literally (no String.replace interpretation)", async () => {
+    const p = write("f.txt", "value = OLD\n");
+    const out = await edit({ path: p, old_text: "OLD", new_text: "$1$&dollar" });
+    expect(out).toContain("Successfully edited");
+    expect(fs.readFileSync(p, "utf8")).toBe("value = $1$&dollar\n");
+  });
+});

package/tests/envcontext.test.ts

@@ -0,0 +1,67 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { gitInfo, buildEnvBlock } from "../src/core/envcontext";
+
+describe("envcontext · gitInfo", () => {
+  let dir: string;
+  beforeEach(() => { dir = fs.mkdtempSync(path.join(os.tmpdir(), "sky-git-")); });
+  afterEach(() => { try { fs.rmSync(dir, { recursive: true, force: true }); } catch {} });
+
+  it("reads the branch from a .git directory HEAD", () => {
+    fs.mkdirSync(path.join(dir, ".git"));
+    fs.writeFileSync(path.join(dir, ".git", "HEAD"), "ref: refs/heads/feature-x\n");
+    const info = gitInfo(dir);
+    expect(info.repo).toBe(true);
+    expect(info.branch).toBe("feature-x");
+  });
+
+  it("falls back to a short sha for a detached HEAD", () => {
+    fs.mkdirSync(path.join(dir, ".git"));
+    fs.writeFileSync(path.join(dir, ".git", "HEAD"), "0123456789abcdef\n");
+    expect(gitInfo(dir).branch).toBe("01234567");
+  });
+
+  it("resolves a worktree .git file pointing at the real gitdir", () => {
+    const real = path.join(dir, "realgit");
+    fs.mkdirSync(real);
+    fs.writeFileSync(path.join(real, "HEAD"), "ref: refs/heads/wt-branch\n");
+    fs.writeFileSync(path.join(dir, ".git"), `gitdir: ${real}\n`);
+    const info = gitInfo(dir);
+    expect(info.repo).toBe(true);
+    expect(info.branch).toBe("wt-branch");
+  });
+
+  it("reports no repo when there is no .git up the tree", () => {
+    const nested = path.join(dir, "a", "b");
+    fs.mkdirSync(nested, { recursive: true });
+    expect(gitInfo(nested).repo).toBe(false);
+  });
+});
+
+describe("envcontext · buildEnvBlock", () => {
+  it("includes cwd, platform, node, git branch and an injectable date (zh)", () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "sky-env-"));
+    try {
+      fs.mkdirSync(path.join(dir, ".git"));
+      fs.writeFileSync(path.join(dir, ".git", "HEAD"), "ref: refs/heads/main\n");
+      const block = buildEnvBlock({ cwd: dir, lang: "zh", now: new Date("2026-06-14T08:00:00Z") });
+      expect(block).toContain("运行环境");
+      expect(block).toContain(dir);
+      expect(block).toContain(process.version);
+      expect(block).toContain(process.platform);
+      expect(block).toContain("main");
+      expect(block).toContain("2026-06-14");
+    } finally {
+      try { fs.rmSync(dir, { recursive: true, force: true }); } catch {}
+    }
+  });
+
+  it("renders an English block", () => {
+    const block = buildEnvBlock({ cwd: os.tmpdir(), lang: "en", now: new Date("2026-01-02T00:00:00Z") });
+    expect(block).toContain("## Environment");
+    expect(block).toContain("Working directory");
+    expect(block).toContain("2026-01-02");
+  });
+});

package/tests/plugins.test.ts

@@ -0,0 +1,84 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { ToolRegistry } from "../src/core/tool";
+import { PluginLoader, type PluginContext } from "../src/plugins/loader";
+
+describe("PluginLoader · hook lifecycle", () => {
+  let reg: ToolRegistry;
+  let loader: PluginLoader;
+  beforeEach(() => {
+    reg = new ToolRegistry();
+    loader = new PluginLoader(reg, { foo: 1 });
+  });
+
+  it("activate-style plugin registers a scoped tool and an init hook", async () => {
+    let initFired = false;
+    loader.activatePlugin("p1", {
+      activate(ctx: PluginContext) {
+        expect(ctx.config).toEqual({ foo: 1 });
+        ctx.registerTool({ name: "p1_tool", description: "t", handler: async () => "ok" });
+        ctx.on("init", () => { initFired = true; });
+      },
+    });
+    expect(reg.has("p1_tool")).toBe(true);
+    expect(loader.list()).toContain("p1");
+    expect(loader.hookCount("init")).toBe(1);
+
+    await loader.emit("init");
+    expect(initFired).toBe(true);
+  });
+
+  it("unload removes the plugin's tools and hook handlers", async () => {
+    let fired = 0;
+    loader.activatePlugin("p", {
+      activate(ctx: PluginContext) {
+        ctx.registerTool({ name: "tmp_tool", description: "t", handler: async () => "ok" });
+        ctx.on("init", () => { fired++; });
+      },
+    });
+    expect(reg.has("tmp_tool")).toBe(true);
+
+    expect(loader.unload("p")).toBe(true);
+    expect(reg.has("tmp_tool")).toBe(false);
+    expect(loader.hookCount("init")).toBe(0);
+    expect(loader.list()).not.toContain("p");
+
+    await loader.emit("init");
+    expect(fired).toBe(0); // handler gone
+  });
+
+  it("fires hook handlers in registration order across plugins", async () => {
+    const order: string[] = [];
+    loader.activatePlugin("a", { activate: (c) => c.on("init", () => { order.push("a"); }) });
+    loader.activatePlugin("b", { activate: (c) => c.on("init", () => { order.push("b"); }) });
+    await loader.emit("init");
+    expect(order).toEqual(["a", "b"]);
+  });
+
+  it("reactivating a name unloads the previous instance (no duplicate tools)", () => {
+    loader.activatePlugin("dup", { activate: (c) => c.registerTool({ name: "x", description: "v1", handler: async () => "1" }) });
+    loader.activatePlugin("dup", { activate: (c) => c.registerTool({ name: "x", description: "v2", handler: async () => "2" }) });
+    expect(loader.list().filter((n) => n === "dup")).toHaveLength(1);
+    expect(reg.get("x")?.description).toBe("v2");
+  });
+
+  it("supports legacy register(registry) and tracks its tools for unload", () => {
+    loader.activatePlugin("legacy", {
+      register(r) { r.register({ name: "legacy_tool", description: "t", handler: async () => "ok" }); },
+    });
+    expect(reg.has("legacy_tool")).toBe(true);
+    loader.unload("legacy");
+    expect(reg.has("legacy_tool")).toBe(false);
+  });
+
+  it("isolates a throwing hook handler from the rest", async () => {
+    const ran: string[] = [];
+    loader.activatePlugin("a", { activate: (c) => c.on("evt", () => { throw new Error("boom"); }) });
+    loader.activatePlugin("b", { activate: (c) => c.on("evt", () => { ran.push("b"); }) });
+    await loader.emit("evt");
+    expect(ran).toEqual(["b"]); // b still ran despite a throwing
+  });
+
+  it("unload returns false for an unknown plugin", () => {
+    expect(loader.unload("nope")).toBe(false);
+  });
+});

package/tests/security.test.ts

@@ -0,0 +1,87 @@
+import { describe, it, expect } from "vitest";
+import {
+  DangerLevel,
+  decideApproval,
+  isEditTool,
+  SecurityContext,
+} from "../src/core/security";
+
+describe("security · decideApproval matrix", () => {
+  it("SAFE is always allowed in every mode", () => {
+    for (const mode of ["auto", "interactive", "strict", "acceptEdits", "bypass"] as const) {
+      expect(decideApproval(DangerLevel.SAFE, mode, "read_file")).toBe("allow");
+    }
+  });
+
+  it("strict denies every non-SAFE tool", () => {
+    expect(decideApproval(DangerLevel.LOW, "strict", "write_file")).toBe("deny");
+    expect(decideApproval(DangerLevel.HIGH, "strict", "run_bash")).toBe("deny");
+  });
+
+  it("bypass allows everything (red-line is gated elsewhere)", () => {
+    expect(decideApproval(DangerLevel.CRITICAL, "bypass", "run_bash")).toBe("allow");
+    expect(decideApproval(DangerLevel.HIGH, "bypass", "deploy")).toBe("allow");
+  });
+
+  it("interactive asks for every non-SAFE tool", () => {
+    expect(decideApproval(DangerLevel.LOW, "interactive", "write_file")).toBe("ask");
+    expect(decideApproval(DangerLevel.HIGH, "interactive", "run_bash")).toBe("ask");
+  });
+
+  it("auto allows LOW, asks MEDIUM/HIGH, denies CRITICAL (unchanged)", () => {
+    expect(decideApproval(DangerLevel.LOW, "auto", "write_file")).toBe("allow");
+    expect(decideApproval(DangerLevel.MEDIUM, "auto", "git_push")).toBe("ask");
+    expect(decideApproval(DangerLevel.HIGH, "auto", "run_bash")).toBe("ask");
+    expect(decideApproval(DangerLevel.CRITICAL, "auto", "run_bash")).toBe("deny");
+  });
+
+  it("acceptEdits waves through edit tools but asks for other risky tools", () => {
+    expect(decideApproval(DangerLevel.LOW, "acceptEdits", "write_file")).toBe("allow");
+    expect(decideApproval(DangerLevel.MEDIUM, "acceptEdits", "delete_file")).toBe("allow"); // edit tool
+    expect(decideApproval(DangerLevel.HIGH, "acceptEdits", "run_bash")).toBe("ask");       // not an edit
+    expect(decideApproval(DangerLevel.CRITICAL, "acceptEdits", "delete_file")).toBe("deny");
+  });
+});
+
+describe("security · isEditTool", () => {
+  it("recognizes filesystem-mutating tools", () => {
+    expect(isEditTool("write_file")).toBe(true);
+    expect(isEditTool("edit_file")).toBe(true);
+    expect(isEditTool("delete_file")).toBe(true);
+    expect(isEditTool("move_file")).toBe(true);
+    expect(isEditTool("read_file")).toBe(false);
+    expect(isEditTool("run_bash")).toBe(false);
+  });
+});
+
+describe("security · checkApproval integration", () => {
+  it("blocks red-line shell commands regardless of mode", async () => {
+    const sec = new SecurityContext({ mode: "bypass" });
+    const [ok, reason] = await sec.checkApproval("run_bash", { command: "rm -rf /" }, "fog");
+    expect(ok).toBe(false);
+    expect(reason.toLowerCase()).toContain("red-line");
+  });
+
+  it("write_file: auto allows, strict denies, acceptEdits allows", async () => {
+    const args = { path: "a.txt", content: "x" };
+    expect((await new SecurityContext({ mode: "auto" }).checkApproval("write_file", args, "rain"))[0]).toBe(true);
+    expect((await new SecurityContext({ mode: "strict" }).checkApproval("write_file", args, "rain"))[0]).toBe(false);
+    expect((await new SecurityContext({ mode: "acceptEdits" }).checkApproval("write_file", args, "rain"))[0]).toBe(true);
+  });
+
+  it("ask defers to the approval callback", async () => {
+    const sec = new SecurityContext({ mode: "interactive" });
+    let asked = false;
+    sec.setApprovalCallback(async () => { asked = true; return false; });
+    const [ok] = await sec.checkApproval("write_file", { path: "a", content: "b" }, "rain");
+    expect(asked).toBe(true);
+    expect(ok).toBe(false);
+  });
+
+  it("setMode switches behavior at runtime", () => {
+    const sec = new SecurityContext({ mode: "auto" });
+    expect(sec.approvalMode).toBe("auto");
+    sec.setMode("bypass");
+    expect(sec.approvalMode).toBe("bypass");
+  });
+});