fix(cli): resolve bundled skills from the package root, not the tshy dist stub

The skills loader resolved the package.json nearest the bundled code, which is
tshy's `dist/esm` dialect stub ({"type":"module"}), so it looked for skills in
`dist/esm/skills` (which does not exist) and reported "No agent skills found"
from every published build. It only worked when run from source via tsx. Walk
up to the first package.json with a name (the real package root) instead, which
resolves correctly both bundled and from source, and also fixes the version
stamp falling back to 0.0.0.

Author: ericallam

packages/cli-v3/src/commands/skills.test.ts

@@ -0,0 +1,61 @@
+import { afterAll, describe, expect, it } from "vitest";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { resolveBundledPackageJSON } from "./skills.js";
+
+/**
+ * Reproduces the published layout: tshy emits a dialect stub `package.json`
+ * ({"type":"module"}) in `dist/esm`, which shadows the real package root when resolving
+ * from the bundled code. The skills dir ships at the package root. Resolution must skip
+ * the stub and land on the root, otherwise `trigger skills` silently finds no skills.
+ */
+async function makeBundledPackage(): Promise<{ root: string; distEsm: string }> {
+  const root = await mkdtemp(join(tmpdir(), "bundled-cli-"));
+
+  await writeFile(
+    join(root, "package.json"),
+    JSON.stringify({ name: "trigger.dev", version: "9.9.9-test.1" })
+  );
+
+  await mkdir(join(root, "skills", "authoring-tasks"), { recursive: true });
+  await writeFile(join(root, "skills", "authoring-tasks", "SKILL.md"), "# Authoring");
+
+  const distEsm = join(root, "dist", "esm");
+  await mkdir(distEsm, { recursive: true });
+  // The tshy dialect stub that caused the bug.
+  await writeFile(join(distEsm, "package.json"), JSON.stringify({ type: "module" }));
+
+  return { root, distEsm };
+}
+
+describe("resolveBundledPackageJSON", () => {
+  const roots: string[] = [];
+
+  afterAll(async () => {
+    await Promise.all(roots.map((d) => rm(d, { recursive: true, force: true })));
+  });
+
+  it("skips the tshy dist/esm dialect stub and resolves the package root", async () => {
+    const { root, distEsm } = await makeBundledPackage();
+    roots.push(root);
+
+    const resolved = await resolveBundledPackageJSON(distEsm);
+
+    // Must be the root package.json (which has `skills/` beside it), not the dist/esm stub.
+    expect(resolved).toBe(join(root, "package.json"));
+    expect(dirname(resolved!)).toBe(root);
+  });
+
+  it("resolves directly when started from a dir under the named package root (source/tsx path)", async () => {
+    const { root } = await makeBundledPackage();
+    roots.push(root);
+
+    const srcDir = join(root, "src");
+    await mkdir(srcDir, { recursive: true });
+
+    const resolved = await resolveBundledPackageJSON(srcDir);
+
+    expect(resolved).toBe(join(root, "package.json"));
+  });
+});

packages/cli-v3/src/commands/skills.ts

@@ -100,10 +100,45 @@ export async function installSkillsCommand(options: unknown) {
  * `sourceDir` (the CLI's location) rather than the user's cwd. The CLI is the only source
  * of skills (there is no remote fallback), so this only returns null in the unexpected
  * case that the CLI ships without any skills.
+ *
+ * tshy emits a dialect stub `package.json` ({"type":"module"}) in `dist/esm`, so the
+ * package.json nearest the bundled code is NOT the package root and has no `skills/`
+ * beside it. We walk up to the first package.json that has a `name` (the real root);
+ * that resolves correctly both when bundled (`<root>/dist/esm`) and from source
+ * (`<root>/src`, run via tsx in dev/tests).
  */
+export async function resolveBundledPackageJSON(startDir: string = sourceDir): Promise<
+  string | null
+> {
+  let searchDir = startDir;
+
+  for (let i = 0; i < 10; i++) {
+    const candidate = await resolvePackageJSON(searchDir);
+    const pkg = await readPackageJSON(candidate);
+
+    if (pkg.name) {
+      return candidate;
+    }
+
+    // Climb above this (stub) package.json and keep looking for the real root.
+    const above = dirname(dirname(candidate));
+    if (above === searchDir) {
+      return null;
+    }
+    searchDir = above;
+  }
+
+  return null;
+}
+
 async function loadSkillsManifest(): Promise<RulesManifest | null> {
   try {
-    const packageJsonPath = await resolvePackageJSON(sourceDir);
+    const packageJsonPath = await resolveBundledPackageJSON();
+
+    if (!packageJsonPath) {
+      return null;
+    }
+
     const pkg = await readPackageJSON(packageJsonPath);
     const skillsDir = join(dirname(packageJsonPath), "skills");
     const version = typeof pkg.version === "string" ? pkg.version : "0.0.0";