@wirecat/cli-template 0.8.0 → 0.10.0

package/src/mcp-http.test.ts

@@ -95,7 +95,10 @@ it("serves the three tools behind the browser login, and shows the server in mcp
   const port = await freePort()
   const base = new URL(`http://127.0.0.1:${port}`)
   const stop = new AbortController()
-  const serving = started(["personal", "mcp", "--http", "--public-url", base.href, "--port", String(port)], stop.signal)
+  const serving = started(
+    ["personal", "mcp", "serve", "--http", "--public-url", base.href, "--port", String(port)],
+    stop.signal,
+  )
   await vi.waitFor(() => expect(serving.err.join("\n")).toContain("serving on"))
   const codes = () => [...serving.err.join("\n").matchAll(/login code for a new browser app: (\S+)/g)].map((m) => m[1])
   const client = await loggedInClient(base, () => codes()[0] ?? "")
@@ -121,30 +124,34 @@ it("serves the three tools behind the browser login, and shows the server in mcp
   expect(await answer(["personal", "mcp", "server", "status", "--json"])).toMatchObject({ running: false })
 })
 
-it("refuses mcp --http without the tunnel's address", async () => {
-  const one = started(["personal", "mcp", "--http", "--json"])
+it("refuses mcp serve --http without the tunnel's address", async () => {
+  const one = started(["personal", "mcp", "serve", "--http", "--json"])
   expect(await one.code).not.toBe(0)
   expect(one.err.join("\n")).toContain("--public-url")
 })
 
-it("forgets every browser login on --revoke", async () => {
-  expect(await answer(["personal", "mcp", "--revoke", "--json"])).toEqual({ revoked: true, profile: "personal" })
+it("forgets every browser login on mcp revoke", async () => {
+  expect(await answer(["personal", "mcp", "revoke", "--json"])).toEqual({ revoked: true, profile: "personal" })
 })
 
 it("keeps the login code out of a background server's log, and refuses a port in use", async () => {
   const port = await freePort()
   const url = `http://127.0.0.1:${port}`
   const stop = new AbortController()
-  const background = started(["personal", "mcp", "--http", "--public-url", url, "--port", String(port)], stop.signal, {
-    ...process.env,
-    CLIDEV_MCP_HTTP: "personal",
-  })
+  const background = started(
+    ["personal", "mcp", "serve", "--http", "--public-url", url, "--port", String(port)],
+    stop.signal,
+    {
+      ...process.env,
+      CLIDEV_MCP_HTTP: "personal",
+    },
+  )
   try {
     await vi.waitFor(() => expect(background.err.join("\n")).toContain("serving on"))
     expect(background.err.join("\n")).toContain(
       "a new login code for a browser app: `clidev personal mcp server status`",
     )
-    const second = started(["work", "mcp", "--http", "--public-url", url, "--port", String(port), "--json"])
+    const second = started(["work", "mcp", "serve", "--http", "--public-url", url, "--port", String(port), "--json"])
     expect(await second.code).not.toBe(0)
     expect(second.err.join("\n")).toContain(`port ${port} is in use`)
   } finally {
@@ -154,12 +161,12 @@ it("keeps the login code out of a background server's log, and refuses a port in
 })
 
 it("refuses --json for MCP over stdio", async () => {
-  const one = started(["personal", "mcp", "--json"])
+  const one = started(["personal", "mcp", "serve", "--json"])
   expect(await one.code).toBe(2)
   expect(one.err.join("\n")).toContain("MCP over stdio controls its own output")
 })
 
-it("refuses --revoke under the read-only lock", async () => {
-  const one = started(["personal", "mcp", "--revoke", "--json"], undefined, { ...process.env, CLIDEV_READ_ONLY: "1" })
+it("refuses mcp revoke under the read-only lock", async () => {
+  const one = started(["personal", "mcp", "revoke", "--json"], undefined, { ...process.env, CLIDEV_READ_ONLY: "1" })
   expect(await one.code).toBe(5)
 })

package/src/mcp.test.ts

@@ -47,7 +47,7 @@ it("finds writes as well as reads", async () => {
   const client = await connect()
   const found = structured(await client.callTool({ name: "clidev_tools_search", arguments: {} }))
   expect(found.items).toContainEqual(expect.objectContaining({ writes: true }))
-  expect(found.items).not.toContainEqual(expect.objectContaining({ command: "mcp" }))
+  expect(found.items).not.toContainEqual(expect.objectContaining({ command: expect.stringMatching(/^mcp\b/) }))
 })
 
 it("runs a command through the CLI and answers with its result", async () => {
@@ -76,9 +76,9 @@ it("serves until the command is stopped", async () => {
   await expect(serving).resolves.toBeUndefined()
 })
 
-it("clidev <profile> mcp starts the server and ends on a signal", async () => {
+it("clidev <profile> mcp serve starts the server and ends on a signal", async () => {
   const stop = new AbortController()
-  const serving = run(["personal", "mcp"], {
+  const serving = run(["personal", "mcp", "serve"], {
     signal: stop.signal,
     tty: false,
     streams: { data: () => {}, diagnostic: () => {} },

package/src/program.test.ts

@@ -127,12 +127,18 @@ it("skill show prints the packaged skill", async () => {
   expect(out).toContain(readFileSync(new URL("../skills/clidev-cli/SKILL.md", import.meta.url), "utf8").split("\n")[0])
 })
 
-it("mcp without a profile stops and says so", async () => {
-  const { code, err } = await ran(["mcp", "--json"])
+it("mcp serve without a profile stops and says so", async () => {
+  const { code, err } = await ran(["mcp", "serve", "--json"])
   expect(code).toBe(2)
   expect(err).toContain("validation_error")
 })
 
+it("mcp alone only names its commands", async () => {
+  const { code, err } = await ran(["personal", "mcp", "--json"])
+  expect(code).toBe(2)
+  expect(err).toContain("--help")
+})
+
 it("upgrade --check installs nothing when npm cannot be reached", async () => {
   const { code, out } = await ran(["upgrade", "--check", "--json"])
   expect(code).toBe(0)

package/src/roots.test.ts

@@ -77,18 +77,13 @@ it("skill status and skill show --for read what skill install wrote", async () =
   expect((await ran(["skill", "install", "--for", "claude", "--json"])).code).toBe(0)
   const status = await ran(["skill", "status", "--json"])
   expect(status.code).toBe(0)
-  // cli-core #2059 wraps skill answers in `{ item, meta }`; accept both until this CLI pins the release that ships it.
-  const answer = (out: string) => {
-    const body = JSON.parse(out)
-    return body.item ?? body
-  }
-  expect(answer(status.out).targets).toEqual([
+  expect(JSON.parse(status.out).item.targets).toEqual([
     expect.objectContaining({ target: "claude", state: "current" }),
     expect.objectContaining({ target: "agents", installed: null, state: "missing" }),
   ])
   const shown = await ran(["skill", "show", "--for", "claude", "--json"])
   expect(shown.code).toBe(0)
-  expect(answer(shown.out)).toMatchObject({
+  expect(JSON.parse(shown.out).item).toMatchObject({
     target: "claude",
     content: expect.stringContaining("name: clidev-cli"),
   })

package/src/version.ts

@@ -1 +1 @@
-export const VERSION = "0.8.0"
+export const VERSION = "0.10.0"