@wirecat/cli-template 0.9.0 → 0.11.0

package/.github/workflows/ci.yml

@@ -35,6 +35,24 @@ jobs:
         contracts:upgrade
       checks: |
         bash scripts/audit.sh
+        pnpm smoke:node
+
+  # WC-TOOL-6: engines allows ^22.16.0; node-ci.yml runs Node 24 only.
+  node-22:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          persist-credentials: false
+      - uses: pnpm/action-setup@ea17c68df8912ef543352723c149a84f56e3d413 # v6.1.0
+      - uses: actions/setup-node@949feb2413d6458794dcd2491c4babbbce0c15c1 # v7.1.0
+        with:
+          node-version: 22.16.0
+          cache: pnpm
+      - run: pnpm install --frozen-lockfile --ignore-scripts
+      - run: pnpm build
+      - run: pnpm test
+      - run: pnpm smoke:node
 
   version:
     if: github.event_name == 'pull_request'

package/.github/workflows/release.yml

@@ -189,3 +189,66 @@ jobs:
         run: |
           awk -v v="$VERSION" '$0 ~ "^## "v" " {on=1; next} /^## / && on {exit} on' CHANGELOG.md |
             gh release create "v$VERSION" --title "$VERSION" --notes-file -
+
+  # The template's own release publishes @wirecat/cli-template, which has no skill on ClawHub.
+  # ClawHub's own workflow, pinned: it runs the ClawHub CLI from this commit and needs id-token only to read which
+  # commit that is. It publishes the skill only when it changed, as the next patch of ClawHub's own version line.
+  clawhub-dry-run:
+    needs: build
+    if: inputs.dry_run && github.repository != 'WireCatLabs/cli-template'
+    permissions:
+      contents: read
+      id-token: write
+    uses: openclaw/clawhub/.github/workflows/skill-publish.yml@52358852d3510f1150756d48e8a72cb8c8e698e0 # main, 2026-10-25
+    with:
+      skill_path: skills/clidev-cli
+      owner: wirecat
+      dry_run: true
+
+  # After the tag, so a ClawHub failure never holds back the npm release. The same CLI commit as the dry run, but run
+  # here instead of through ClawHub's workflow, which GitHub cannot let fail: a version stuck pending ClawHub's scan
+  # is not counted as the latest, so the next publish picks it again and gets "already exists" (openclaw/clawhub#4046).
+  # That one error warns; any other fails. Bump CLAWHUB_SHA together with the dry run's pin.
+  clawhub:
+    needs: tag
+    if: ${{ !inputs.dry_run && github.repository != 'WireCatLabs/cli-template' }}
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    env:
+      SKILL_PATH: skills/clidev-cli
+      CLAWHUB_SLUG: wirecat-clidev
+      CLAWHUB_SHA: 52358852d3510f1150756d48e8a72cb8c8e698e0
+      CLAWHUB_URL: https://clawhub.ai
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          persist-credentials: false
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          repository: openclaw/clawhub
+          ref: ${{ env.CLAWHUB_SHA }}
+          path: clawhub-source
+          persist-credentials: false
+      - uses: oven-sh/setup-bun@0c5077e51419868618aeaa5fe8019c62421857d6 # v2.2.0
+        with:
+          bun-version: 1.4.4
+      - run: bun install --frozen-lockfile
+        working-directory: clawhub-source
+      - name: publish the skill
+        env:
+          CLAWHUB_TOKEN: ${{ secrets.CLAWHUB_TOKEN }}
+          CLAWHUB_CONFIG_PATH: ${{ runner.temp }}/clawhub-config.json
+        run: |
+          (umask 077; jq -n --arg r "$CLAWHUB_URL" --arg t "$CLAWHUB_TOKEN" '{registry: $r, token: $t}' > "$CLAWHUB_CONFIG_PATH")
+          status=0
+          output=$(bun clawhub-source/packages/clawhub/src/cli.ts --workdir "$GITHUB_WORKSPACE" \
+            --site "$CLAWHUB_URL" --registry "$CLAWHUB_URL" skill publish "$SKILL_PATH" --slug "$CLAWHUB_SLUG" --json \
+            --owner wirecat --tags latest --source-repo "$GITHUB_REPOSITORY" --source-commit "$GITHUB_SHA" \
+            --source-path "$SKILL_PATH" --source-ref "$GITHUB_REF" 2>&1) || status=$?
+          echo "$output"
+          if [ "$status" -ne 0 ] && grep -q "already exists" <<< "$output"; then
+            echo "::warning::ClawHub already has this skill version, still pending its stalled scan — not republished (openclaw/clawhub#4046)"
+            exit 0
+          fi
+          exit "$status"

package/CHANGELOG.md

@@ -3,7 +3,78 @@
 Notable changes to `@wirecat/cli-template`. One section per version, newest first; versions follow
 [semantic versioning](https://semver.org), so before `1.0.0` the skeleton may still change.
 
-<!-- cspell:words katex smol whatsapp -->
+<!-- cspell:words clawhub gcal katex openclaw smol whatsapp -->
+
+## 0.11.0 — 31.10.2026
+
+### Added
+
+- **`pnpm test:slow`** lists the 20 slowest tests and the 10 slowest files (WC-TEST-5).
+- **A Node 22.16.0 job in `ci.yml`** builds, runs the tests and runs the built bin, since `engines` allows Node 22 and
+  full validation runs only on Node 24 (WC-TOOL-6).
+- **The release skill re-checks the comparison page** at each release: each mark against the release build, and the
+  check date and version in the intro (WC-CMP-11).
+
+### Changed — may break callers
+
+- **The skeleton runs on cli-core 0.495.0** (from 0.469.0); cli-base stays at 0.65.0. The root help's "Works with"
+  list now names gcal and mail.
+
+### Fixed
+
+- **`scripts/audit.sh` passes the CLI's own entity schemas and error reasons** (`--schemas`, `--reasons`) from
+  `commands info`, so the audit measures same-entity-schema and same-error-reason for it, as gcal-cli's does.
+- **The scripts that run the CLI in throwaway folders hide the keyring** with `DBUS_SESSION_BUS_ADDRESS=disabled:`:
+  `scripts/audit.sh`, `scripts/smoke.ts` and `scripts/smoke-bundle.ts`. Moved folders alone do not hide it, since it
+  is reached over D-Bus. `scripts/` is not updated by `upgrade`, so an existing CLI copies these by hand;
+  `scripts/audit.sh` is updated.
+- **`pnpm package:check` refuses a `files` list that ships `src`, `scripts`, `.github`, `bin/release`, `config`, `lint`,
+  `contracts`, `docs/dev` or `template.json`** (WC-REL-16); it only checked that npm packs what `files` names. The
+  template's own package still ships them, since `new` copies them. `scripts/` is not updated by `upgrade`, so an
+  existing CLI copies the check from `scripts/smoke.ts` by hand.
+- **0.10.0's note that runs record successes too was wrong for the skeleton.** A built skeleton keeps only a failed
+  run, from a terminal or an agent, and also with `--record`, as the README and the settings page say.
+
+## 0.10.0 — 31.10.2026
+
+### Changed — may break callers
+
+- **The skeleton runs on cli-core 0.469.0 and cli-base 0.65.0**; a CLI that pins cli-base moves both pins together.
+  A non-messenger CLI no longer offers messenger settings or the `follow-ups` and `link-conversations` skills
+  (cli-core 0.468); runs record successes too, under cli-core 0.467's rules. cli-base 0.64 adds `cli-dev bundle`, the
+  shared build that ships the bin as an esbuild bundle, and calendar words in the command vocabulary. cli-base 0.65 adds
+  the verbs `serve` and `revoke`, and `cli-dev lint` fails on a baseline entry that names them: the skeleton's
+  `lint/baseline/unknown-verb.json` (`mcp serve`, `mcp revoke`) is gone, and a CLI made from the template removes the
+  same entries. `<cli> upgrade` now restarts the HTTP MCP server that `mcp server start` started, on the new version,
+  and names the MCP sessions over stdio that still run the old one (cli-core #2117).
+
+### Added
+
+- **A CLI made from the template publishes its skill on ClawHub as `wirecat-<command>` after each release.** `release.yml`
+  gets a dry run through ClawHub's pinned workflow and, after the tag, a publish that only warns while ClawHub still holds
+  the version pending its scan ([openclaw/clawhub#4046](https://github.com/openclaw/clawhub/issues/4046)); the template's
+  own release skips both. The skill names its binary and npm package for OpenClaw (`metadata.openclaw`). It needs the
+  `CLAWHUB_TOKEN` secret, which the WireCatLabs organization shares.
+- **`new --category calendar` names gcal-cli as the reference CLI** in `AGENTS.md` and `DESIGN.md`, and the
+  Reference CLIs page lists it, instead of "No reference CLI for this category yet". gcal-cli is the WireCat Google
+  Calendar CLI. A CLI made before this keeps what it wrote; edit its `AGENTS.md` by hand if you want the link.
+- **`scripts/audit.sh` audits beside gcal-cli too**: it installs `@wirecat/gcal-cli` with the other published CLIs
+  and passes its `gcal` bin to `cli-dev audit`.
+- **An agent publishes a release itself.** The release skill and `bin/release` let an agent merge the release pull
+  request and run `bin/release`, which publishes from GitHub Actions. `bin/release --local` stays the owner's, for
+  the first release.
+
+### Fixed
+
+- **The release audit never uses the owner's accounts.** Its prompt now says: no sign-in, every folder moved, the
+  keyring hidden with `DBUS_SESSION_BUS_ADDRESS=disabled:`, and no command that writes to a service.
+- **`bin/release` raises the next free version to the level the changelog needs.** When npm already had the version, it
+  took the next patch, so a release with `Added` (`0.1.1` taken, `0.1.2` proposed) failed `version:check` and stopped;
+  it now proposes `0.2.0`. A generated CLI gets it with the next template update.
+- **A CLI made from the template starts from an esbuild bundle.** `pnpm build` runs `tsc`, then cli-base's
+  `cli-dev bundle` ([WC-LAY-10](https://github.com/WireCatLabs/cli-base/blob/main/docs/standards/layout.md)), and the
+  bin becomes a loader for `dist/bundle/`: the skeleton's `config show --help` starts in 151 ms instead of 366.
+  `scripts/smoke-bundle.ts` runs the bundle under Node (`pnpm smoke:node`, in CI) and Bun (`pnpm smoke:bun`).
 
 ## 0.9.0 — 27.10.2026
 

package/CLAUDE.md

@@ -8,9 +8,7 @@ permissions. A gap in cli-core is fixed in cli-core.
 
 ## Local rules
 
-- **Before `1.0.0`, `Added` raises the minor too.** This narrows the handbook's
-  [WC-REL-7](node_modules/@wirecat/cli-base/docs/standards/releases.md): the levels are in step 6 of the
-  [release skill](docs/dev/skills/release/SKILL.md), and `pnpm version:check` refuses a version raised too little.
+None yet.
 
 Add a rule here only when it holds for `clidev` alone, and link the handbook rule it narrows.
 

package/bin/release

@@ -1,7 +1,8 @@
 #!/usr/bin/env sh
-# Publishes the version in package.json and tags it. Run on a clean `main` that matches origin/main; the owner runs
-# it, never an agent. When npm already has that version, or a higher one, it raises it to the next free one through a
-# pull request and publishes that (WC-REL-5). Nothing is published until `pnpm release:check` passes.
+# Publishes the version in package.json and tags it. Run on a clean `main` that matches origin/main. An agent may run
+# it without --local; --local is for the owner's first release only. When npm already has that version, or a higher
+# one, it raises it to the next free one through a pull request and publishes that (WC-REL-5). Nothing is published
+# until `pnpm release:check` passes.
 #
 #   bin/release           # publishes from GitHub Actions (.github/workflows/release.yml, npm trusted publishing)
 #   bin/release --local   # publishes from this computer: NPM_TOKEN if exported, else the keyring, else `npm login`
@@ -110,6 +111,7 @@ next=$(pnpm exec cli-dev next-version "$version" "$latest" "$versions")
 if [ "$next" != "$version" ]; then
   taken=""
   if published; then taken=1; why="$version is already on npm"; else why="$version is not above npm's latest $latest"; fi
+  next=$(node --experimental-strip-types scripts/version-level.ts --next "$next")
   echo "$why — publishing $next instead"
   # A version npm already has keeps its changelog section; the unreleased one becomes the new version.
   node -e 'const fs = require("fs"); const [o, n, taken] = process.argv.slice(1)

package/contracts/help.snap

@@ -9,7 +9,9 @@ Works with:
   wa                      WhatsApp in the same local store: search, review and tasks offline
   zm                      Zoom meetings: transcripts and summaries, searchable with your other WireCat data
   drive                   Google Drive and Docs as local text, searchable with your other WireCat data
+  gcal                    Google Calendar events, searchable with your other WireCat data
   memo context <person>   one person across messengers, mail, notes and meetings
+  mail                    IMAP mail in the same local store: search your mailbox offline, next to your other WireCat data
 
 Next:         clidev commands      every command, by section
               clidev help options  output, offline, timeouts, dry run

package/dist/bin/clidev.js

@@ -1,14 +1,36 @@
 #!/usr/bin/env node
-import { enableCompileCache } from "node:module";
-import { catchCrashes } from "@wirecat/cli-base";
-import { IDENTITY } from "../identity.js";
-enableCompileCache();
-const stopCatching = catchCrashes({ cli: IDENTITY.command, interactive: process.stdout.isTTY === true });
-const { run } = await import("../program.js");
-try {
-    process.exitCode = await run(process.argv.slice(2));
+// cli-dev bundle loader
+import * as module from "node:module"
+
+const words = process.argv.slice(2)
+// As the CLI answers it, unless a test records the argv: then the CLI writes the record too.
+if (
+  words.length === 1 &&
+  (words[0] === "--version" || words[0] === "-V") &&
+  !Object.keys(process.env).some((key) => key.endsWith("_TEST_ARGV_LOG"))
+) {
+  process.stdout.write("0.11.0\n")
+} else {
+  // Before the bundle compiles: the bundle's own call comes after its chunks.
+  module.enableCompileCache()
+  const serves = ((words) => {
+    const plain = words.filter((word) => !word.startsWith("-"));
+    return plain
+        .slice(0, 4)
+        .some((word, at) => word === "serve" || word === "watch" || (word === "mcp" && plain[at + 1] === undefined));
+})(words)
+  if (serves && module.registerHooks) {
+    const bundle = new URL("../bundle/", import.meta.url).href
+    module.registerHooks({
+      resolve: (specifier, context, next) =>
+        specifier.startsWith("./") && context.parentURL?.startsWith(bundle)
+          ? { url: new URL(specifier, context.parentURL).href, format: "module", shortCircuit: true }
+          : next(specifier, context),
+    })
+  }
+  const running = import("../bundle/clidev.js")
+  const chunks = ["../bundle/all-profiles-MJ6XSFOO.js","../bundle/anthropic-W5UKBZUB.js","../bundle/app-server-EZ46JAHB.js","../bundle/bun-HB6O2TTT.js","../bundle/bun-sqlite-KBXOW2ES.js","../bundle/decode-AMXUVKNY.js","../bundle/dist-ESHIQU4M.js","../bundle/echarts-GJDMQ2AQ.js","../bundle/embed-L4CRZ2XQ.js","../bundle/embedder-IBGV4M2K.js","../bundle/first-screen-X5IJKBSU.js","../bundle/instructions-YJECS4KN.js","../bundle/mcp-G6XP2IRO.js","../bundle/mcp-OQBZXELQ.js","../bundle/mcp-RDZGYPSY.js","../bundle/node-NQG4EVZR.js","../bundle/node-P4E63KXA.js","../bundle/node-TLZSIHIJ.js","../bundle/node-sqlite-BR7F3BLB.js","../bundle/oauth-J7UAWNIK.js","../bundle/open-BR47R5UE.js","../bundle/process-66I7RDPJ.js","../bundle/program-K6347XBZ.js","../bundle/prompt-NE5JJ7UP.js","../bundle/recognize-GC3YFVIA.js","../bundle/remote-QELOMKQM.js","../bundle/rerank-BH6TZ2SP.js","../bundle/serve-WWLRNDT2.js","../bundle/server-DE6NLNUF.js","../bundle/server-ZPSQKOAH.js","../bundle/state-2BEGXAMO.js","../bundle/store-AH6WZMCF.js","../bundle/store-maintenance-command-PBXX3IEV.js"]
+  // After the server answers its first request, so it starts no later.
+  if (serves) setTimeout(() => void Promise.allSettled(chunks.map((chunk) => import(chunk))), 2000).unref()
+  await running
 }
-finally {
-    stopCatching();
-}
-//# sourceMappingURL=clidev.js.map

package/dist/bundle/all-profiles-MJ6XSFOO.js

@@ -0,0 +1,24 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  CHILD_IDLE_MS,
+  allProfilesServer,
+  serveAllProfilesOverHttp,
+  serveAllProfilesOverStdio,
+  withProfile
+} from "./chunk-HDY5X3WQ.js";
+import "./chunk-IN3FVRPK.js";
+import "./chunk-IBBN7Z3A.js";
+import "./chunk-5D4AEUVA.js";
+import "./chunk-MJRSEUKG.js";
+import "./chunk-O5EHUB2V.js";
+import "./chunk-EFHLQXG6.js";
+import "./chunk-Y5E2WNWB.js";
+import "./chunk-ZVVMGPBJ.js";
+export {
+  CHILD_IDLE_MS,
+  allProfilesServer,
+  serveAllProfilesOverHttp,
+  serveAllProfilesOverStdio,
+  withProfile
+};

package/dist/bundle/anthropic-W5UKBZUB.js

@@ -0,0 +1,70 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  checkedOptions
+} from "./chunk-PDGXMKJS.js";
+import {
+  messagesFor,
+  systemFor
+} from "./chunk-NOVLCHDV.js";
+import {
+  Anthropic
+} from "./chunk-ADLS6FVG.js";
+import {
+  array,
+  optional,
+  strictObject,
+  string
+} from "./chunk-EFHLQXG6.js";
+import "./chunk-Y5E2WNWB.js";
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.495.0_@wirecat+cli-base@0.65.0_commander@15.0.0_esbuild@0.28.2_type_24cca5e5c8b0984f2f26e7d1ba6b6d47/node_modules/@wirecat/cli-core/dist/models/anthropic.js
+var options = strictObject({
+  stop_sequences: optional(array(string()))
+});
+var anthropic = {
+  images: true,
+  baseUrl: "https://api.anthropic.com",
+  validate: /* @__PURE__ */ __name((given) => checkedOptions("anthropic", options, given), "validate"),
+  complete: /* @__PURE__ */ __name(async (target, request, checked, apiKey, fetcher) => {
+    const client = new Anthropic({
+      apiKey: apiKey ?? "",
+      authToken: null,
+      fetch: /* @__PURE__ */ __name((input, init) => fetcher(input, { ...init, redirect: "error" }), "fetch"),
+      baseURL: target.baseUrl,
+      maxRetries: 0,
+      logLevel: "off",
+      timeout: 12e4
+    });
+    const response = await client.messages.stream({
+      ...checked,
+      model: target.model,
+      system: systemFor(request),
+      messages: [
+        ...messagesFor(request),
+        ...request.images === void 0 ? [] : [
+          {
+            role: "user",
+            content: request.images.map((image) => ({
+              type: "image",
+              source: { type: "base64", media_type: image.mimeType, data: image.data }
+            }))
+          }
+        ]
+      ],
+      max_tokens: request.maxTokens
+    }).finalMessage();
+    if (response.stop_reason !== "end_turn")
+      throw new Error("incomplete response");
+    return {
+      text: response.content.filter((block) => block.type === "text").map((block) => block.text).join(""),
+      tokens: response.usage.input_tokens + response.usage.output_tokens + (response.usage.cache_creation_input_tokens ?? 0) + (response.usage.cache_read_input_tokens ?? 0)
+    };
+  }, "complete")
+};
+export {
+  anthropic
+};

package/dist/bundle/app-server-EZ46JAHB.js

@@ -0,0 +1,217 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  PER_RUN,
+  envelope
+} from "./chunk-N2Z3MCOF.js";
+import "./chunk-ERKR3VJ5.js";
+import {
+  mcpUrlOf
+} from "./chunk-JAOGZMKQ.js";
+import {
+  answeredWire
+} from "./chunk-IN3FVRPK.js";
+import {
+  answered,
+  failed,
+  registerCommands,
+  runCommandForAgent,
+  toolsFromCommands
+} from "./chunk-YJNUDHJD.js";
+import {
+  agentJson,
+  skillResource
+} from "./chunk-4LURWBVV.js";
+import {
+  StdioServerTransport,
+  serveStdio
+} from "./chunk-IBBN7Z3A.js";
+import "./chunk-L5WWMP5M.js";
+import "./chunk-FZZIU4B7.js";
+import "./chunk-KJTNT4SW.js";
+import "./chunk-E42W72PQ.js";
+import "./chunk-MFS52LTZ.js";
+import {
+  appInstructions
+} from "./chunk-ERGB4NJA.js";
+import {
+  McpServer
+} from "./chunk-5D4AEUVA.js";
+import {
+  mcpHttpMarker
+} from "./chunk-V3ZTQ24B.js";
+import "./chunk-RUKDZEID.js";
+import "./chunk-OV6PHTAY.js";
+import "./chunk-PBN4RBHS.js";
+import "./chunk-35KYY65W.js";
+import "./chunk-NOVLCHDV.js";
+import "./chunk-IGHEW777.js";
+import "./chunk-MUSYGFCY.js";
+import {
+  DEFAULT_OUTPUT_BYTES,
+  changesAuthorityAt,
+  describeProgram,
+  environmentOf,
+  fetchesOnlyAt,
+  judgedTargets,
+  readOnlyLockOf,
+  rootOf2 as rootOf
+} from "./chunk-QJ6XW4DM.js";
+import "./chunk-MJRSEUKG.js";
+import "./chunk-O3UXNU3S.js";
+import "./chunk-VYSUKHKL.js";
+import "./chunk-VLNKTMV7.js";
+import "./chunk-O5EHUB2V.js";
+import "./chunk-FDBINRWA.js";
+import "./chunk-QKWRL4OD.js";
+import "./chunk-EGRB55FF.js";
+import "./chunk-IDWW4TU2.js";
+import "./chunk-2B5U4Z5H.js";
+import {
+  CliError,
+  mcpErrorResult
+} from "./chunk-EFHLQXG6.js";
+import "./chunk-Y5E2WNWB.js";
+import "./chunk-Z7MSIRSQ.js";
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.495.0_@wirecat+cli-base@0.65.0_commander@15.0.0_esbuild@0.28.2_type_24cca5e5c8b0984f2f26e7d1ba6b6d47/node_modules/@wirecat/cli-core/dist/mcp/app-server.js
+var EXCLUDED = [["mcp"]];
+var createAppServer = /* @__PURE__ */ __name((command, context, options) => {
+  const { app } = options;
+  const root = rootOf(command);
+  const environment = environmentOf(command);
+  if (!environment.runCommand)
+    throw new Error("the MCP server runs inside run(), which hands it the program");
+  const program = { run: environment.runCommand, commands: describeProgram(root) };
+  const flags = command.optsWithGlobals();
+  const overrides = flags.permission ?? [];
+  const { settings } = context;
+  const levels = /* @__PURE__ */ __name(() => options.resolveSettings(flags, { env: context.env }).permissions, "levels");
+  const readOnly = /* @__PURE__ */ __name(() => readOnlyLockOf(app, context.env) !== void 0, "readOnly");
+  const authority = changesAuthorityAt(root);
+  const targets = judgedTargets(root);
+  const passed = Object.fromEntries(Object.entries(environment).filter(([key]) => !PER_RUN.has(key)));
+  const tools = toolsFromCommands(program.commands, {
+    includeUnavailable: true,
+    exclude: EXCLUDED,
+    levels: settings.permissions,
+    currentLevels: levels,
+    readOnly: readOnly(),
+    authority,
+    fetchOnly: fetchesOnlyAt(root),
+    permissions: options.permissions
+  });
+  const availability = /* @__PURE__ */ __name((one) => () => {
+    const permitted = one.availability?.() ?? { available: true };
+    if (!permitted.available)
+      return permitted;
+    return options.availability?.(one.path, settings.profile) ?? permitted;
+  }, "availability");
+  const commands = Object.fromEntries(tools.map((one) => [
+    one.command,
+    {
+      title: one.title,
+      description: one.description,
+      writes: one.writes,
+      availability: availability(one),
+      input: one.input,
+      run: /* @__PURE__ */ __name(async (input, ctx) => {
+        const own = options.availability?.(one.path, settings.profile);
+        if (own && !own.available)
+          return failed(new CliError("permission_error", `${one.command}: ${own.reason ?? "unavailable for this profile"}`, {
+            ...own.permission ? { permission: own.permission } : {}
+          }), app.errors);
+        const traceparent = ctx?.mcpReq?._meta?.traceparent;
+        const env = typeof traceparent === "string" ? { ...context.env, TRACEPARENT: traceparent } : context.env;
+        const answer = await runCommandForAgent(program, one.path, input, {
+          profile: settings.profile,
+          readOnly: readOnly(),
+          env,
+          levels,
+          overrides,
+          authority,
+          permissions: options.permissions,
+          environment: passed
+        });
+        if ("error" in answer)
+          return mcpErrorResult(JSON.parse(agentJson(answer.error)));
+        try {
+          return answered(envelope(one.command, answer.result), DEFAULT_OUTPUT_BYTES, targets);
+        } catch (error) {
+          return failed(error, app.errors);
+        }
+      }, "run")
+    }
+  ]));
+  const skill = options.skill ? skillResource(app, options.skill) : void 0;
+  const build = /* @__PURE__ */ __name(() => {
+    const server = new McpServer({ name: app.command, version: app.version }, {
+      instructions: appInstructions({
+        command: app.command,
+        name: options.name,
+        profile: settings.profile,
+        untrusted: options.untrusted,
+        ...skill ? { skill: skill.instruction } : {}
+      })
+    });
+    registerCommands(server, app.command, commands, app.errors, void 0, app.messenger);
+    if (skill) {
+      const { uri, name, title, description, mimeType, read } = skill;
+      server.registerResource(name, uri, { title, description, mimeType }, read);
+    }
+    return server;
+  }, "build");
+  return { build, offered: Object.keys(commands) };
+}, "createAppServer");
+var serveAppOverStdio = /* @__PURE__ */ __name(async (command, context, options) => {
+  const { build } = createAppServer(command, context, options);
+  const { stdin, stdout, signal } = environmentOf(command);
+  const own = stdin && stdout && stdin !== process.stdin;
+  const wire = answeredWire(own ? stdin : process.stdin, own ? stdout : process.stdout);
+  const handle = serveStdio(build, {
+    transport: new StdioServerTransport(wire.input, wire.output),
+    onerror: /* @__PURE__ */ __name((error) => context.renderer.note(`mcp: ${error.message}`), "onerror")
+  });
+  const ended = await new Promise((resolve) => {
+    wire.ended.then(() => resolve("input"));
+    if (own)
+      signal?.addEventListener("abort", () => resolve("stopped"), { once: true });
+    else {
+      process.once("SIGINT", () => resolve("stopped"));
+      process.once("SIGTERM", () => resolve("stopped"));
+    }
+  });
+  if (ended === "input")
+    await wire.answered();
+  wire.release();
+  await handle.close();
+}, "serveAppOverStdio");
+var serveAppOverHttp = /* @__PURE__ */ __name(async (command, context, options, http) => {
+  const { app } = options;
+  const { build } = createAppServer(command, context, options);
+  const { serveOverHttp } = await import("./serve-WWLRNDT2.js");
+  const listening = await serveOverHttp(build, {
+    ...http,
+    appName: app.command,
+    onCode: /* @__PURE__ */ __name((code, expires) => context.renderer.note(context.env[mcpHttpMarker(app.envPrefix)] === void 0 ? `login code for a new browser app: ${code} (until ${expires.toTimeString().slice(0, 5)}; a new one after each login)` : `a new login code for a browser app: \`${app.command} ${context.settings.profile} mcp server status\``), "onCode"),
+    onError: /* @__PURE__ */ __name((error) => context.renderer.note(`mcp: ${error.message}`), "onError")
+  }).catch((error) => {
+    if (error.code === "EADDRINUSE")
+      throw new CliError("configuration_error", `port ${http.port} is in use \u2014 pass another with --port`);
+    throw error;
+  });
+  context.renderer.note(`serving on ${listening.url.href} \u2014 point your tunnel at it; connectors use ${mcpUrlOf(http.publicUrl).href}`);
+  await new Promise((resolve) => {
+    process.once("SIGINT", resolve);
+    process.once("SIGTERM", resolve);
+  });
+  await listening.close();
+}, "serveAppOverHttp");
+export {
+  createAppServer,
+  serveAppOverHttp,
+  serveAppOverStdio
+};