@vellumai/assistant 0.8.1 → 0.8.2

package/src/__tests__/skills-install-staging.test.ts

@@ -0,0 +1,159 @@
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { gzipSync } from "node:zlib";
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+const mockExecSync = mock(() => {});
+
+mock.module("node:child_process", () => ({
+  execSync: mockExecSync,
+}));
+
+import { loadSkillCatalog } from "../config/skills.js";
+import { installSkillLocally } from "../skills/catalog-install.js";
+import { installExternalSkill } from "../skills/skillssh-registry.js";
+import { makeTar } from "./helpers/tar-fixtures.js";
+
+const originalWorkspaceDir = process.env.VELLUM_WORKSPACE_DIR;
+const originalFetch = globalThis.fetch;
+
+let workspaceDir: string;
+
+function skillMarkdown(name: string, body: string): string {
+  return `---
+name: "${name}"
+description: "A test skill."
+---
+
+${body}
+`;
+}
+
+function writeInstalledSkill(skillId: string, name: string): void {
+  const skillDir = join(workspaceDir, "skills", skillId);
+  mkdirSync(skillDir, { recursive: true });
+  writeFileSync(join(skillDir, "SKILL.md"), skillMarkdown(name, "Old body."));
+  writeFileSync(join(skillDir, "old.txt"), "keep me\n");
+}
+
+beforeEach(() => {
+  workspaceDir = mkdtempSync(join(tmpdir(), "skills-install-staging-"));
+  process.env.VELLUM_WORKSPACE_DIR = workspaceDir;
+  mkdirSync(join(workspaceDir, "skills"), { recursive: true });
+  mockExecSync.mockReset();
+  mockExecSync.mockImplementation(() => {
+    throw new Error("dependency install failed");
+  });
+});
+
+afterEach(() => {
+  globalThis.fetch = originalFetch;
+  if (originalWorkspaceDir === undefined) {
+    delete process.env.VELLUM_WORKSPACE_DIR;
+  } else {
+    process.env.VELLUM_WORKSPACE_DIR = originalWorkspaceDir;
+  }
+  rmSync(workspaceDir, { recursive: true, force: true });
+});
+
+describe("staged skill installs", () => {
+  test("catalog dependency failure does not leave a discoverable fresh install", async () => {
+    const archive = gzipSync(
+      makeTar([
+        {
+          name: "SKILL.md",
+          content: skillMarkdown("Demo Skill", "New body."),
+        },
+        {
+          name: "package.json",
+          content: JSON.stringify({ dependencies: { example: "1.0.0" } }),
+        },
+      ]),
+    );
+    globalThis.fetch = mock(
+      async () => new Response(archive),
+    ) as unknown as typeof fetch;
+
+    await expect(
+      installSkillLocally(
+        "demo-skill",
+        {
+          id: "demo-skill",
+          name: "Demo Skill",
+          description: "A test skill.",
+        },
+        false,
+      ),
+    ).rejects.toThrow("dependency install failed");
+
+    expect(
+      existsSync(join(workspaceDir, "skills", "demo-skill", "SKILL.md")),
+    ).toBe(false);
+    expect(loadSkillCatalog().some((skill) => skill.id === "demo-skill")).toBe(
+      false,
+    );
+  });
+
+  test("skills.sh overwrite dependency failure preserves the previous skill", async () => {
+    writeInstalledSkill("demo-skill", "Old Demo Skill");
+
+    globalThis.fetch = mock(async (input: string | URL | Request) => {
+      const url = String(input);
+      if (url.includes("/contents/skills/demo-skill")) {
+        return new Response(
+          JSON.stringify([
+            {
+              name: "SKILL.md",
+              type: "file",
+              download_url: "https://example.com/SKILL.md",
+            },
+            {
+              name: "package.json",
+              type: "file",
+              download_url: "https://example.com/package.json",
+            },
+            {
+              name: "new.txt",
+              type: "file",
+              download_url: "https://example.com/new.txt",
+            },
+          ]),
+        );
+      }
+      if (url.endsWith("/SKILL.md")) {
+        return new Response(skillMarkdown("New Demo Skill", "New body."));
+      }
+      if (url.endsWith("/package.json")) {
+        return new Response(
+          JSON.stringify({ dependencies: { example: "1.0.0" } }),
+        );
+      }
+      if (url.endsWith("/new.txt")) {
+        return new Response("new file\n");
+      }
+      return new Response("not found", { status: 404 });
+    }) as unknown as typeof fetch;
+
+    await expect(
+      installExternalSkill("owner", "repo", "demo-skill", true),
+    ).rejects.toThrow("dependency install failed");
+
+    const skillDir = join(workspaceDir, "skills", "demo-skill");
+    expect(readFileSync(join(skillDir, "SKILL.md"), "utf-8")).toContain(
+      "Old Demo Skill",
+    );
+    expect(readFileSync(join(skillDir, "old.txt"), "utf-8")).toBe("keep me\n");
+    expect(existsSync(join(skillDir, "new.txt"))).toBe(false);
+    expect(
+      loadSkillCatalog().find((skill) => skill.id === "demo-skill")?.name,
+    ).toBe("Old Demo Skill");
+  });
+});

package/src/__tests__/skills-uninstall.test.ts

@@ -53,81 +53,49 @@ afterEach(() => {
 });
 
 describe("assistant skills uninstall", () => {
-  test("removes skill directory and SKILLS.md entry", () => {
-    /**
-     * Tests the happy path for uninstalling a skill.
-     */
-
-    // GIVEN a skill is installed locally
+  test("removes skill directory while leaving a stale SKILLS.md index unchanged", () => {
     installFakeSkill("weather");
-    writeSkillsIndex("- weather\n- vellum-self-knowledge\n");
+    const originalIndex = "- weather\n- vellum-self-knowledge\n";
+    writeSkillsIndex(originalIndex);
 
-    // WHEN we uninstall the skill
     uninstallSkillLocally("weather");
 
-    // THEN the skill directory should be removed
     expect(existsSync(join(getSkillsDir(), "weather"))).toBe(false);
 
-    // AND the SKILLS.md entry should be removed
     const index = readFileSync(getSkillsIndexPath(), "utf-8");
-    expect(index).not.toContain("weather");
-
-    // AND other skills should remain in the index
-    expect(index).toContain("vellum-self-knowledge");
+    expect(index).toBe(originalIndex);
   });
 
   test("errors when skill is not installed", () => {
-    /**
-     * Tests that uninstalling a non-existent skill throws an error.
-     */
-
-    // GIVEN no skills are installed
-    // WHEN we try to uninstall a nonexistent skill
-    // THEN it should throw an error
     expect(() => uninstallSkillLocally("nonexistent")).toThrow(
       'Skill "nonexistent" is not installed.',
     );
   });
 
-  test("works when SKILLS.md does not exist", () => {
-    /**
-     * Tests that uninstall works even if the SKILLS.md index file is missing.
-     */
-
-    // GIVEN a skill directory exists but no SKILLS.md
+  test("works when no stale SKILLS.md index exists", () => {
     installFakeSkill("weather");
 
-    // WHEN we uninstall the skill
     uninstallSkillLocally("weather");
 
-    // THEN the skill directory should be removed
     expect(existsSync(join(getSkillsDir(), "weather"))).toBe(false);
 
-    // AND no SKILLS.md should have been created
     expect(existsSync(getSkillsIndexPath())).toBe(false);
   });
 
-  test("removes skill with nested files", () => {
-    /**
-     * Tests that uninstall recursively removes skills with nested directories.
-     */
-
-    // GIVEN a skill with nested files is installed
+  test("removes skill with nested files while leaving a stale SKILLS.md index unchanged", () => {
     const skillDir = join(getSkillsDir(), "weather");
     mkdirSync(join(skillDir, "scripts", "lib"), { recursive: true });
     writeFileSync(join(skillDir, "SKILL.md"), "# weather\n");
     writeFileSync(join(skillDir, "scripts", "fetch.sh"), "#!/bin/bash\n");
     writeFileSync(join(skillDir, "scripts", "lib", "utils.sh"), "# utils\n");
-    writeSkillsIndex("- weather\n");
+    const originalIndex = "- weather\n";
+    writeSkillsIndex(originalIndex);
 
-    // WHEN we uninstall the skill
     uninstallSkillLocally("weather");
 
-    // THEN the entire skill directory tree should be removed
     expect(existsSync(skillDir)).toBe(false);
 
-    // AND the SKILLS.md entry should be removed
     const index = readFileSync(getSkillsIndexPath(), "utf-8");
-    expect(index).not.toContain("weather");
+    expect(index).toBe(originalIndex);
   });
 });

package/src/__tests__/skills.test.ts

@@ -67,42 +67,62 @@ describe("skills catalog loading", () => {
       rmSync(skillsDir, { recursive: true, force: true });
   });
 
-  test("parses markdown list path entries from SKILLS.md", () => {
-    writeSkill("alpha", "Alpha Skill", "First skill");
-    writeSkill("beta", "Beta Skill", "Second skill");
-    writeFileSync(
-      join(TEST_DIR, "skills", "SKILLS.md"),
-      "- alpha\n- beta/SKILL.md\n",
-    );
+  test("discovers valid skill directories alphabetically", () => {
+    writeSkill("zeta", "Zeta Skill", "Zeta");
+    writeSkill("alpha", "Alpha Skill", "Alpha");
 
     const catalog = loadUserSkillCatalog();
-    expect(catalog.map((skill) => skill.id)).toEqual(["alpha", "beta"]);
+    expect(catalog.map((skill) => skill.id)).toEqual(["alpha", "zeta"]);
   });
 
-  test("resolves markdown links from SKILLS.md", () => {
-    writeSkill("lint", "Lint Skill", "Runs lint checks");
-    writeSkill("test", "Test Skill", "Runs test checks");
+  test("ignores stale SKILLS.md while discovering valid skill directories", () => {
+    writeSkill("first", "First Skill", "First");
+    writeSkill("second", "Second Skill", "Second");
     writeFileSync(
       join(TEST_DIR, "skills", "SKILLS.md"),
-      "- [Lint](lint)\n- [Tests](test)\n",
+      "- second\n- missing\n",
     );
 
     const catalog = loadUserSkillCatalog();
-    expect(catalog.map((skill) => skill.id)).toEqual(["lint", "test"]);
+    expect(catalog.map((skill) => skill.id)).toEqual(["first", "second"]);
+  });
+
+  test("managed skill overrides bundled skill with the same id", () => {
+    writeSkill(
+      "skill-management",
+      "Custom Skill Management",
+      "Managed override",
+    );
+
+    const skill = loadSkillCatalog().find((s) => s.id === "skill-management");
+    expect(skill).toBeDefined();
+    expect(skill!.source).toBe("managed");
+    expect(skill!.name).toBe("Custom Skill Management");
+    expect(skill!.bundled).toBeUndefined();
   });
 
-  test("rejects SKILLS.md entries that resolve outside ~/.vellum/workspace/skills", () => {
-    writeSkill("safe", "Safe Skill", "Safe skill");
+  test("discovers symlinked skill directories that point inside ~/.vellum/workspace/skills", () => {
+    const internalSkillDir = join(
+      TEST_DIR,
+      "skills",
+      ".linked-targets",
+      "internal-skill",
+    );
+    mkdirSync(internalSkillDir, { recursive: true });
     writeFileSync(
-      join(TEST_DIR, "skills", "SKILLS.md"),
-      "- ../escape\n- /tmp/absolute\n- safe\n",
+      join(internalSkillDir, "SKILL.md"),
+      '---\nname: "Internal Linked Skill"\ndescription: "Inside skills root."\n---\n\nLoad me.\n',
     );
 
+    symlinkSync(internalSkillDir, join(TEST_DIR, "skills", "linked-skill"));
+
     const catalog = loadUserSkillCatalog();
-    expect(catalog.map((skill) => skill.id)).toEqual(["safe"]);
+    expect(catalog).toHaveLength(1);
+    expect(catalog[0].id).toBe("linked-skill");
+    expect(catalog[0].name).toBe("Internal Linked Skill");
   });
 
-  test("rejects symlinked SKILLS.md entries that point outside ~/.vellum/workspace/skills", () => {
+  test("does not discover symlinked skill directories that point outside ~/.vellum/workspace/skills", () => {
     const externalSkillDir = join(TEST_DIR, "outside", "external-skill");
     mkdirSync(externalSkillDir, { recursive: true });
     writeFileSync(
@@ -111,7 +131,6 @@ describe("skills catalog loading", () => {
     );
 
     symlinkSync(externalSkillDir, join(TEST_DIR, "skills", "linked-skill"));
-    writeFileSync(join(TEST_DIR, "skills", "SKILLS.md"), "- linked-skill\n");
 
     const catalog = loadUserSkillCatalog();
     expect(catalog).toHaveLength(0);
@@ -130,35 +149,6 @@ describe("skills catalog loading", () => {
     );
 
     symlinkSync(externalSkillFile, join(linkedSkillDir, "SKILL.md"));
-    writeFileSync(
-      join(TEST_DIR, "skills", "SKILLS.md"),
-      "- linked-file-skill\n",
-    );
-
-    const catalog = loadUserSkillCatalog();
-    expect(catalog).toHaveLength(0);
-  });
-
-  test("uses SKILLS.md ordering when index exists", () => {
-    writeSkill("first", "First Skill", "First");
-    writeSkill("second", "Second Skill", "Second");
-    writeFileSync(join(TEST_DIR, "skills", "SKILLS.md"), "- second\n- first\n");
-
-    const catalog = loadUserSkillCatalog();
-    expect(catalog.map((skill) => skill.id)).toEqual(["second", "first"]);
-  });
-
-  test("falls back to auto-discovery when SKILLS.md is missing", () => {
-    writeSkill("zeta", "Zeta Skill", "Zeta");
-    writeSkill("alpha", "Alpha Skill", "Alpha");
-
-    const catalog = loadUserSkillCatalog();
-    expect(catalog.map((skill) => skill.id)).toEqual(["alpha", "zeta"]);
-  });
-
-  test("treats SKILLS.md as authoritative when present", () => {
-    writeSkill("available", "Available Skill", "Present on disk");
-    writeFileSync(join(TEST_DIR, "skills", "SKILLS.md"), "- ../invalid-only\n");
 
     const catalog = loadUserSkillCatalog();
     expect(catalog).toHaveLength(0);
@@ -248,6 +238,18 @@ describe("workspace skills", () => {
     expect(result.skill!.body).toBe("Full workspace body here");
     expect(result.skill!.source).toBe("workspace");
   });
+
+  test("workspace skill overrides managed skill with the same id", () => {
+    writeSkill("shared-id", "Managed Shared", "Managed version");
+    writeWorkspaceSkill("shared-id", "Workspace Shared", "Workspace version");
+
+    const skill = loadSkillCatalog(workspaceSkillsDir).find(
+      (s) => s.id === "shared-id",
+    );
+    expect(skill).toBeDefined();
+    expect(skill!.source).toBe("workspace");
+    expect(skill!.name).toBe("Workspace Shared");
+  });
 });
 
 describe("tool manifest detection", () => {
@@ -449,7 +451,6 @@ describe("includes frontmatter parsing", () => {
 
   test("parses valid includes array", () => {
     writeSkillWithIncludes("parent", '["child-a", "child-b"]');
-    writeFileSync(join(TEST_DIR, "skills", "SKILLS.md"), "- parent\n");
     const catalog = loadUserSkillCatalog();
     const skill = catalog.find((s) => s.id === "parent");
     expect(skill).toBeDefined();
@@ -458,7 +459,6 @@ describe("includes frontmatter parsing", () => {
 
   test("trims whitespace in includes entries", () => {
     writeSkillWithIncludes("parent", '["  child-a  ", " child-b "]');
-    writeFileSync(join(TEST_DIR, "skills", "SKILLS.md"), "- parent\n");
     const catalog = loadUserSkillCatalog();
     const skill = catalog.find((s) => s.id === "parent");
     expect(skill!.includes).toEqual(["child-a", "child-b"]);
@@ -466,7 +466,6 @@ describe("includes frontmatter parsing", () => {
 
   test("removes empty strings from includes", () => {
     writeSkillWithIncludes("parent", '["child-a", "", "  ", "child-b"]');
-    writeFileSync(join(TEST_DIR, "skills", "SKILLS.md"), "- parent\n");
     const catalog = loadUserSkillCatalog();
     const skill = catalog.find((s) => s.id === "parent");
     expect(skill!.includes).toEqual(["child-a", "child-b"]);
@@ -474,7 +473,6 @@ describe("includes frontmatter parsing", () => {
 
   test("deduplicates includes preserving first-seen order", () => {
     writeSkillWithIncludes("parent", '["child-a", "child-b", "child-a"]');
-    writeFileSync(join(TEST_DIR, "skills", "SKILLS.md"), "- parent\n");
     const catalog = loadUserSkillCatalog();
     const skill = catalog.find((s) => s.id === "parent");
     expect(skill!.includes).toEqual(["child-a", "child-b"]);
@@ -482,7 +480,6 @@ describe("includes frontmatter parsing", () => {
 
   test("returns undefined for invalid JSON", () => {
     writeSkillWithIncludes("parent", "not-json");
-    writeFileSync(join(TEST_DIR, "skills", "SKILLS.md"), "- parent\n");
     const catalog = loadUserSkillCatalog();
     const skill = catalog.find((s) => s.id === "parent");
     expect(skill!.includes).toBeUndefined();
@@ -490,7 +487,6 @@ describe("includes frontmatter parsing", () => {
 
   test("returns undefined for non-array JSON", () => {
     writeSkillWithIncludes("parent", '"just-a-string"');
-    writeFileSync(join(TEST_DIR, "skills", "SKILLS.md"), "- parent\n");
     const catalog = loadUserSkillCatalog();
     const skill = catalog.find((s) => s.id === "parent");
     expect(skill!.includes).toBeUndefined();
@@ -498,7 +494,6 @@ describe("includes frontmatter parsing", () => {
 
   test("returns undefined for array with non-string elements", () => {
     writeSkillWithIncludes("parent", "[123, true]");
-    writeFileSync(join(TEST_DIR, "skills", "SKILLS.md"), "- parent\n");
     const catalog = loadUserSkillCatalog();
     const skill = catalog.find((s) => s.id === "parent");
     expect(skill!.includes).toBeUndefined();
@@ -506,7 +501,6 @@ describe("includes frontmatter parsing", () => {
 
   test("returns undefined for empty array", () => {
     writeSkillWithIncludes("parent", "[]");
-    writeFileSync(join(TEST_DIR, "skills", "SKILLS.md"), "- parent\n");
     const catalog = loadUserSkillCatalog();
     const skill = catalog.find((s) => s.id === "parent");
     expect(skill!.includes).toBeUndefined();
@@ -514,7 +508,6 @@ describe("includes frontmatter parsing", () => {
 
   test("skill without includes has undefined includes", () => {
     writeSkill("no-includes", "No Includes", "Test");
-    writeFileSync(join(TEST_DIR, "skills", "SKILLS.md"), "- no-includes\n");
     const catalog = loadUserSkillCatalog();
     const skill = catalog.find((s) => s.id === "no-includes");
     expect(skill!.includes).toBeUndefined();

package/src/__tests__/slack-channel-config.test.ts

@@ -48,6 +48,9 @@ mock.module("../config/loader.js", () => ({
       teamName:
         ((configStore.slack as Record<string, unknown>)?.teamName as string) ??
         "",
+      teamUrl:
+        ((configStore.slack as Record<string, unknown>)?.teamUrl as string) ??
+        "",
       botUserId:
         ((configStore.slack as Record<string, unknown>)?.botUserId as string) ??
         "",
@@ -277,6 +280,7 @@ describe("Slack channel config handler", () => {
       slack: {
         teamId: "T123",
         teamName: "TestTeam",
+        teamUrl: "https://example.slack.com/",
         botUserId: "U_BOT",
         botUsername: "testbot",
       },
@@ -285,6 +289,7 @@ describe("Slack channel config handler", () => {
     const result = await getSlackChannelConfig();
     expect(result.teamId).toBe("T123");
     expect(result.teamName).toBe("TestTeam");
+    expect(result.teamUrl).toBe("https://example.slack.com/");
     expect(result.botUserId).toBe("U_BOT");
     expect(result.botUsername).toBe("testbot");
   });
@@ -314,6 +319,7 @@ describe("Slack channel config handler", () => {
           ok: true,
           team_id: "T_TEAM",
           team: "MyTeam",
+          url: "https://myteam.slack.com/",
           user_id: "U_BOT",
           user: "mybot",
         }),
@@ -329,11 +335,13 @@ describe("Slack channel config handler", () => {
     expect(result.hasBotToken).toBe(true);
     expect(result.teamId).toBe("T_TEAM");
     expect(result.teamName).toBe("MyTeam");
+    expect(result.teamUrl).toBe("https://myteam.slack.com/");
 
     // Assert metadata was written to config (not credential metadata)
     const slack = configStore.slack as Record<string, unknown>;
     expect(slack.teamId).toBe("T_TEAM");
     expect(slack.teamName).toBe("MyTeam");
+    expect(slack.teamUrl).toBe("https://myteam.slack.com/");
     expect(slack.botUserId).toBe("U_BOT");
     expect(slack.botUsername).toBe("mybot");
   });
@@ -397,6 +405,7 @@ describe("Slack channel config handler", () => {
     const slack = configStore.slack as Record<string, unknown>;
     expect(slack.teamId).toBe("");
     expect(slack.teamName).toBe("");
+    expect(slack.teamUrl).toBe("");
     expect(slack.botUserId).toBe("");
     expect(slack.botUsername).toBe("");
   });

package/src/__tests__/subagent-tool-filtering.test.ts

@@ -68,4 +68,54 @@ describe("subagent-only tool filtering", () => {
     // A regular tool not in SUBAGENT_ONLY_TOOL_NAMES should still be active
     expect(isToolActiveForContext("bash", ctx)).toBe(true);
   });
+
+  test("respects subagentAllowedTools — tools outside the allowlist are inactive", () => {
+    // Mirrors `createResolveToolsCallback`'s post-filter so callers see the
+    // same final tool set the LLM receives.
+    const ctx: SkillProjectionContext = {
+      skillProjectionState: new Map(),
+      skillProjectionCache: {},
+      coreToolNames: new Set(),
+      toolsDisabledDepth: 0,
+      hasNoClient: false,
+      isSubagent: true,
+      subagentAllowedTools: new Set(["bash"]),
+    };
+
+    expect(isToolActiveForContext("bash", ctx)).toBe(true);
+    expect(isToolActiveForContext("ask_question", ctx)).toBe(false);
+    expect(isToolActiveForContext(TEST_TOOL_NAME, ctx)).toBe(false);
+  });
+
+  test("returns false for every tool when toolsDisabledDepth > 0", () => {
+    // `createResolveToolsCallback` returns an empty tool list when tools are
+    // disabled; mirror it here so this helper reports the same final tool set.
+    const ctx: SkillProjectionContext = {
+      skillProjectionState: new Map(),
+      skillProjectionCache: {},
+      coreToolNames: new Set(),
+      toolsDisabledDepth: 1,
+      hasNoClient: false,
+    };
+
+    expect(isToolActiveForContext("bash", ctx)).toBe(false);
+    expect(isToolActiveForContext("ask_question", ctx)).toBe(false);
+  });
+
+  test("under disk-pressure cleanup mode, only cleanup-safe tools are active", () => {
+    // `createResolveToolsCallback` restricts the turn to cleanup-safe tools
+    // (`file_remove`, `bash`, etc.); ensure the helper agrees.
+    const ctx: SkillProjectionContext = {
+      skillProjectionState: new Map(),
+      skillProjectionCache: {},
+      coreToolNames: new Set(),
+      toolsDisabledDepth: 0,
+      hasNoClient: false,
+      diskPressureCleanupModeActive: true,
+    };
+
+    // `bash` is in DISK_PRESSURE_CLEANUP_TOOL_NAMES; `ask_question` is not.
+    expect(isToolActiveForContext("bash", ctx)).toBe(true);
+    expect(isToolActiveForContext("ask_question", ctx)).toBe(false);
+  });
 });