@mediamonks/canopy-cli 0.7.30 → 0.7.32

package/dist/docs/cli-mcp.md

@@ -0,0 +1,88 @@
+---
+title: canopy mcp
+description: Let AI agents use a project's backend as MCP tools — check access, print client config, and run the stdio server.
+---
+
+`canopy mcp` connects AI agents (Claude Code, Claude Desktop, Cursor, any MCP
+client) to a project's tools. The agent always acts as you. See
+[Agent tools](https://docs.canopy.website/guides/agent-tools) for how a project offers tools.
+
+## Usage
+
+```bash
+canopy mcp add [slug] [--channel staging]
+canopy mcp serve [slug] [--channel staging] [--local]
+```
+
+## canopy mcp add
+
+Checks that you're signed in and may open the project, reports how many tools
+it serves, and prints configuration for your client: a `claude mcp add` line
+for Claude Code, and an `mcpServers` JSON block for Claude Desktop, Cursor and
+others. It writes nothing; copy what you need.
+
+The printed command names the site (`--profile`) and, for staging, the
+channel, so it keeps working whatever your default site is. It contains no
+credentials.
+
+## canopy mcp serve
+
+The MCP server your client starts. It talks MCP on stdin/stdout and writes
+nothing else there, so everything it has to say goes to stderr, where clients
+show it as the server's log.
+
+It uses your `canopy login`: it exchanges it for short-lived credentials for
+this one project, keeps them in memory, and renews them as needed. If you're
+not signed in, it exits with a message telling you to run `canopy login`.
+
+Only the project's tools reach the agent, and the tool list stays current: a
+redeploy with new tools reaches a running session without restarting
+anything.
+
+## Arguments & flags
+
+- `slug` — the project. Defaults to the `canopy.json` in the current directory.
+- `--channel <live|staging>` — which channel's backend to use. Default `live`.
+- `--local` (serve only) — use the tools of the `canopy dev` running in the
+  current directory instead of the deployed project.
+- `--profile <id>` — which Canopy site, as for every command.
+
+## Examples
+
+```bash
+canopy mcp add notes
+```
+
+Check you can use `notes` and print its client configuration.
+
+```bash
+claude mcp add canopy-notes -- canopy mcp serve notes --profile main
+```
+
+Add `notes` to Claude Code (the line `canopy mcp add` printed).
+
+```bash
+claude mcp add notes-staging -- canopy mcp serve notes --channel staging --profile main
+```
+
+Try the staging channel's tools before promoting them.
+
+```bash
+claude mcp add notes-local -- canopy mcp serve --local
+```
+
+While developing: the tools from your working tree, served by `canopy dev`.
+
+## When it can't connect
+
+`canopy mcp add` and `canopy mcp serve` say what's wrong in plain words. The
+usual cases:
+
+- **Not signed in** — run `canopy login`.
+- **Limited to its collaborators** — ask the owner to add you.
+- **No backend, or serves no tools** — the project has no `worker/`, or it
+  doesn't mount any tools yet.
+- **Redeploy required** — the backend was deployed before tools existed. Run
+  `canopy deploy`.
+- **Invalid tool definitions** — two tools share a name, or a schema is wrong.
+  The message names the tool.

package/dist/docs/developers-agents-and-ai.md

@@ -64,6 +64,14 @@ already knows the rules:
   use `canopy dev --local` for an offline sandbox where writes never reach
   the platform.
 
+## Give agents your project's tools
+
+The other way round: your project can offer its backend to agents as MCP
+tools, so a colleague's Claude Code or Cursor can call it (as them) without
+opening the app. Wrap the routes you already have with `mountMcpTools`, deploy,
+and people connect with `canopy mcp add <slug>`. See
+[Agent tools](https://docs.canopy.website/guides/agent-tools).
+
 ## Prompts that work
 
 With the skill installed, these are safe, copy-pasteable asks — each maps to

package/dist/docs/index.json

@@ -67,6 +67,11 @@
           "title": "CI and deploy tokens",
           "summary": "Push-to-main deploys using a project-scoped deploy token."
         },
+        {
+          "slug": "agent-tools",
+          "title": "Agent tools (MCP)",
+          "summary": "Let AI agents like Claude Code and Cursor use your project's backend as tools — as the person running them."
+        },
         {
           "slug": "porting-nextjs",
           "title": "Porting a Next.js app",
@@ -286,6 +291,11 @@
           "title": "canopy feedback",
           "summary": "Read and triage a project's feedback inbox, or file a bug/feedback report — against a project or against Canopy itself."
         },
+        {
+          "slug": "cli-mcp",
+          "title": "canopy mcp",
+          "summary": "Let AI agents use a project's backend as MCP tools — check access, print client config, and run the stdio server."
+        },
         {
           "slug": "cli-open",
           "title": "canopy open",
@@ -353,6 +363,11 @@
           "title": "Realtime",
           "summary": "Live updates between the people using your app — subscribe to a topic, publish to it, no backend needed."
         },
+        {
+          "slug": "sdk-mcp",
+          "title": "Agent tools (MCP)",
+          "summary": "\"@mediamonks/canopy/mcp — serve your backend's tools to AI agents: mountMcpTools, createMcpToolsHandler, MCP_PATH and mcpCaller.\""
+        },
         {
           "slug": "sdk-google",
           "title": "Google",

package/dist/docs/sdk-mcp.md

@@ -0,0 +1,222 @@
+---
+title: Agent tools (MCP)
+description: "@mediamonks/canopy/mcp — serve your backend's tools to AI agents: mountMcpTools, createMcpToolsHandler, MCP_PATH and mcpCaller."
+---
+
+`@mediamonks/canopy/mcp` turns your backend into a set of MCP tools that AI
+agents call through `canopy mcp serve`, always as the signed-in Monk running
+them. It is a separate entry of the SDK, for backend code only: browser
+bundles never include it.
+
+```ts
+import { createMcpToolsHandler, MCP_PATH, mcpCaller, mountMcpTools } from "@mediamonks/canopy/mcp";
+```
+
+For the why and the how-to, read the [Agent tools guide](https://docs.canopy.website/guides/agent-tools).
+This page lists the exports and what they accept.
+
+## mountMcpTools(app, tools, options?)
+
+Serves `tools` at `MCP_PATH` on a Hono app. Route tools run this same app's
+routes.
+
+```ts
+import { mountMcpTools } from "@mediamonks/canopy/mcp";
+import { z } from "zod";
+
+mountMcpTools(app, [
+  {
+    name: "list_notes",
+    description: "List the current user's notes, newest first",
+    route: "GET /api/notes",
+    annotations: { readOnlyHint: true },
+  },
+  {
+    name: "summarise",
+    description: "Summarise a note",
+    inputSchema: z.object({ id: z.string() }),
+    handler: async ({ id }, ctx) => summarise(ctx.env, id),
+  },
+]);
+```
+
+- `app` — your Hono app, or anything with `all(path, handler)` and
+  `fetch(request, env, ctx)`.
+- `tools` — a list of [tool definitions](#tool-definitions) and
+  [AI SDK tool sets](#vercel-ai-sdk-tool-sets), mixed.
+- `options` — optional `{ name?, version? }`: the server name and version MCP
+  clients see. The name defaults to your project's slug.
+
+## createMcpToolsHandler(tools, options?)
+
+The same thing without Hono: returns a handler you route `MCP_PATH` to
+yourself.
+
+```ts
+import { createMcpToolsHandler, MCP_PATH } from "@mediamonks/canopy/mcp";
+
+const tools = createMcpToolsHandler(myTools, { app });
+
+export default {
+  fetch(request, env, ctx) {
+    if (new URL(request.url).pathname === MCP_PATH) return tools(request, env, ctx);
+    return app.fetch(request, env, ctx);
+  },
+};
+```
+
+**Returns** `(request, env?, executionCtx?) => Promise<Response>`. Pass the
+backend's `env` so handlers and route tools see `env.USER`, `env.CANOPY` and
+your secrets.
+
+**Options:** `{ app?, name?, version? }`. `app` is required when the list has
+route tools: they run its routes.
+
+Each request gets a fresh, stateless MCP server built on the official
+`@modelcontextprotocol/server`. It speaks both the current MCP protocol and
+the 2025 revision, so older clients work too.
+
+## Tool definitions
+
+A tool is an object in the MCP specification's shape, plus either a `handler`
+or a `route`:
+
+| Field          | Type                           |                                                                                       |
+| -------------- | ------------------------------ | ------------------------------------------------------------------------------------- |
+| `name`         | `string`                       | Required. Unique; letters, digits, `_`, `-` and `.`, at most 128.                     |
+| `description`  | `string`                       | What it does and when to use it. The agent reads this.                                |
+| `title`        | `string`                       | A display name.                                                                       |
+| `inputSchema`  | JSON Schema or Standard Schema | The arguments. Defaults to "no arguments".                                            |
+| `outputSchema` | JSON Schema or Standard Schema | Shape of the structured result, if you want clients to rely on it.                    |
+| `annotations`  | `McpToolAnnotations`           | Hints: `readOnlyHint`, `destructiveHint`, `idempotentHint`, `openWorldHint`, `title`. |
+| `handler`      | `(args, ctx) => unknown`       | Runs the tool.                                                                        |
+| `route`        | `"<METHOD> /path"`             | Runs one of your routes instead.                                                      |
+
+**Schemas** can be plain JSON Schema or any schema that implements Standard
+Schema with JSON Schema output: Zod 4, Valibot (with `toStandardJsonSchema`),
+ArkType. Arguments are validated against `inputSchema` before your handler or
+route runs. Invalid arguments come back to the agent as an error naming the
+field.
+
+**Annotations** matter to agents. Mark tools that change nothing with
+`readOnlyHint: true`. Unmarked tools are treated as possibly destructive, and
+clients usually ask the user before calling them.
+
+### Handler tools
+
+```ts
+{
+  name: "add_comment",
+  inputSchema: z.object({ noteId: z.string(), text: z.string().max(2000) }),
+  handler: async ({ noteId, text }, ctx) => {
+    const env = ctx.env as Env; // your backend's Env type
+    const canopy = createCanopy({ fetch: env.CANOPY.fetch.bind(env.CANOPY) });
+    return canopy.db.collection("comments").insert({ noteId, text, by: ctx.user?.email });
+  },
+}
+```
+
+What the handler returns becomes the result:
+
+- an object — sent as structured content, with a JSON text copy;
+- a string — sent as text;
+- an MCP `CallToolResult` (`{ content, structuredContent?, isError? }`) —
+  sent as is;
+- nothing — an empty result.
+
+Throw to report a failure. The agent gets a tool error with your message.
+
+**`ctx`** (`McpToolContext`):
+
+- `user` — the signed-in Monk (`{ sub, email, name }`), or `null`.
+- `agent` — `true` when an AI agent made the call through `canopy mcp`.
+- `toolCallId` — this call's id, for logs.
+- `signal` — an `AbortSignal`, aborted when the agent cancels.
+- `request` — the HTTP request the call arrived on, without platform
+  credentials.
+- `env` — your backend's env, as routes get it. Typed `unknown`: cast it to
+  your `Env`.
+
+`canopy.*` calls from a handler act as the user, as they would for that
+person's browser.
+
+### Route tools
+
+```ts
+{ name: "get_note", route: "GET /api/notes/:id", inputSchema: z.object({ id: z.string() }) }
+```
+
+The route runs in-process, with the same `env` and identity:
+
+- `:name` segments of the path are filled from the argument of that name. A
+  missing one is a tool error.
+- `GET` and `DELETE`: the other arguments become the query string (arrays
+  repeat the key, objects are sent as JSON).
+- `POST`, `PUT`, `PATCH`: the other arguments become a JSON body.
+- A 2xx JSON response becomes the result (structured when it's an object).
+  Other 2xx bodies become text.
+- Any other status becomes a tool error: `HTTP 403: {"error":"not_owner"}`.
+
+### Vercel AI SDK tool sets
+
+Put a tool set in the list as it is. Each key becomes a tool name:
+
+```ts
+import { tool } from "ai";
+
+const aiTools = {
+  weather: tool({
+    description: "Weather in a city",
+    inputSchema: z.object({ city: z.string() }),
+    execute: async ({ city }) => ({ city, tempC: 21 }),
+  }),
+};
+
+mountMcpTools(app, [...myTools, aiTools]);
+```
+
+`execute` gets the arguments and `{ toolCallId, abortSignal, messages: [] }`.
+Tools without `execute` are skipped. If the result is a stream, its last value
+is the answer.
+
+## MCP_PATH
+
+`"/__canopy/mcp"` — the one path on your backend that agents reach. Mount your
+own MCP server there if you don't use `mountMcpTools`. It must answer on that
+single URL with MCP's streamable HTTP transport.
+
+## mcpCaller(request, env?)
+
+Who is calling, in any route or in your own MCP server:
+
+```ts
+app.get("/api/notes", (c) => {
+  const { user, agent } = mcpCaller(c.req.raw, c.env);
+  // agent is true for a tools call that ran this route
+});
+```
+
+**Returns** `McpCaller`: `{ user: McpUser | null, agent: boolean }`.
+`user` comes from `env.USER`. Without `env`, it falls back to the identity the
+platform attached to the request.
+
+## When the tool list is wrong
+
+The list is checked on the first request. A duplicate or invalid name, a tool
+with neither or both of `handler` and `route`, a route tool without `app`, or
+a schema that can't describe itself as JSON Schema makes the tools endpoint
+answer `500 invalid_tools`, naming the tool. `canopy mcp add` shows that
+message. The rest of your backend keeps working.
+
+## Limits
+
+`canopy mcp serve` holds back tools whose description is over 2,048
+characters or whose input schema is over 16 KB, shows at most 64 tools, turns
+results over 512 KB into an error, and stops a call after 60 seconds.
+
+## Types
+
+All exported from `@mediamonks/canopy/mcp`: `McpTool`, `McpHandlerTool`,
+`McpRouteTool`, `McpToolAnnotations`, `McpToolContext`, `McpToolsInput`,
+`McpToolsOptions`, `McpCaller`, `McpUser`, `AiSdkToolSet`, `ToolSchema`,
+`JsonSchema`, `StandardSchemaLike`, `FetchApp`, `HttpMethod`.

package/dist/{docs-Dg0UJugG.mjs → docs-CtNH5kbN.mjs}

@@ -1,7 +1,7 @@
-import { t as version } from "./package-CnS450Yc.mjs";
+import { t as version } from "./package-YGjjin4p.mjs";
 import { n as siteConfig } from "./site-DM2J10CB.mjs";
 import { i as latestKnownVersion, r as compareSemver } from "./version-check-CcsA1QjI.mjs";
-import { r as reportErrors } from "./ui-CeupNHNa.mjs";
+import { r as reportErrors } from "./ui-C_jSc1Kz.mjs";
 import { defineCommand } from "citty";
 import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";

package/dist/{egress-Cn9zDfDT.mjs → egress-If_Gsx_M.mjs}

@@ -1,5 +1,6 @@
 import { a as projectDirArgs, c as resolveProject } from "./site-DM2J10CB.mjs";
-import { a as unwrap, d as withContext, i as requireTty, l as apiRequest, r as reportErrors, t as formatDateTime } from "./ui-CeupNHNa.mjs";
+import { i as apiRequest, o as withContext } from "./api-C4rMhE7i.mjs";
+import { a as unwrap, i as requireTty, r as reportErrors, t as formatDateTime } from "./ui-C_jSc1Kz.mjs";
 import { defineCommand } from "citty";
 import * as p from "@clack/prompts";
 //#region src/egress.ts

package/dist/{feedback-Dvb6CdlP.mjs → feedback-_L3vqktY.mjs}

@@ -1,6 +1,7 @@
-import { t as version } from "./package-CnS450Yc.mjs";
+import { t as version } from "./package-YGjjin4p.mjs";
 import { a as projectDirArgs, c as resolveProject, d as tryResolveProject, n as siteConfig, u as tryReadCanopyJson } from "./site-DM2J10CB.mjs";
-import { c as apiDownload, l as apiRequest, r as reportErrors, t as formatDateTime, u as apiUpload } from "./ui-CeupNHNa.mjs";
+import { a as apiUpload, i as apiRequest, r as apiDownload } from "./api-C4rMhE7i.mjs";
+import { r as reportErrors, t as formatDateTime } from "./ui-C_jSc1Kz.mjs";
 import { defineCommand } from "citty";
 import { basename, extname, join } from "node:path";
 import { readFile, writeFile } from "node:fs/promises";

package/dist/index.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as version } from "./package-CnS450Yc.mjs";
+import { t as version } from "./package-YGjjin4p.mjs";
 import { r as siteHeaderLine, t as setInvocationProfile } from "./site-DM2J10CB.mjs";
 import { a as notifyOfUpdate, o as runRefresh } from "./version-check-CcsA1QjI.mjs";
 import { defineCommand, runMain } from "citty";
@@ -18,6 +18,7 @@ import { defineCommand, runMain } from "citty";
 *   logs [--follow]       read the project's worker logs          [phase 2]
 *   usage                 AI spend + storage for a project        [phase 1]
 *   ai models             the site's AI models and auto/* aliases
+*   mcp add|serve         a project's tools for AI agents (docs/49)
 *   open                  open the deployed project / dashboard   [phase 1]
 */
 if (process.env["CANOPY_UPDATE_REFRESH"] === "1") {
@@ -61,36 +62,38 @@ const main = defineCommand({
 		description: "canopy — create and deploy vibecoded projects"
 	},
 	subCommands: {
-		login: () => import("./login-MX0xq8UE.mjs").then((m) => m.loginCommand),
-		whoami: () => import("./login-MX0xq8UE.mjs").then((m) => m.whoamiCommand),
-		logout: () => import("./login-MX0xq8UE.mjs").then((m) => m.logoutCommand),
-		create: () => import("./projects-BG7Injpb.mjs").then((m) => m.createCommand),
-		init: () => import("./projects-BG7Injpb.mjs").then((m) => m.initCommand),
-		projects: () => import("./projects-BG7Injpb.mjs").then((m) => m.projectsCommand),
-		delete: () => import("./projects-BG7Injpb.mjs").then((m) => m.deleteCommand),
-		dev: () => import("./dev-DGCu9MjB.mjs").then((m) => m.devCommand),
-		deploy: () => import("./deploy-CBf44bvG.mjs").then((m) => m.deployCommand),
-		promote: () => import("./deploy-CBf44bvG.mjs").then((m) => m.promoteCommand),
-		staging: () => import("./staging-D06zobnf.mjs").then((m) => m.stagingCommand),
-		rollback: () => import("./deploy-CBf44bvG.mjs").then((m) => m.rollbackCommand),
-		download: () => import("./deploy-CBf44bvG.mjs").then((m) => m.downloadCommand),
-		token: () => import("./token-C_PFNqcv.mjs").then((m) => m.tokenCommand),
-		egress: () => import("./egress-Cn9zDfDT.mjs").then((m) => m.egressCommand),
-		secrets: () => import("./secrets-Bl3uOx4l.mjs").then((m) => m.secretsCommand),
-		schedule: () => import("./schedule-CLuksxSM.mjs").then((m) => m.scheduleCommand),
-		feedback: () => import("./feedback-Dvb6CdlP.mjs").then((m) => m.feedbackCommand),
-		db: () => import("./db-KTLn8J1u.mjs").then((m) => m.dbCommand),
-		usage: () => import("./usage-CV7TjTO8.mjs").then((m) => m.usageCommand),
-		ai: () => import("./ai-fAvjdjVX.mjs").then((m) => m.aiCommand),
-		open: () => import("./open-BJgd0R61.mjs").then((m) => m.openCommand),
-		docs: () => import("./docs-Dg0UJugG.mjs").then((m) => m.docsCommand),
-		skill: () => import("./skill-CuES7kPj.mjs").then((m) => m.skillCommand),
-		upgrade: () => import("./upgrade-C8YdSKKd.mjs").then((m) => m.upgradeCommand),
-		logs: () => import("./logs-D5RWqsWl.mjs").then((m) => m.logsCommand)
+		login: () => import("./login-B-m-i8uu.mjs").then((m) => m.loginCommand),
+		whoami: () => import("./login-B-m-i8uu.mjs").then((m) => m.whoamiCommand),
+		logout: () => import("./login-B-m-i8uu.mjs").then((m) => m.logoutCommand),
+		create: () => import("./projects-CN2YhCZn.mjs").then((m) => m.createCommand),
+		init: () => import("./projects-CN2YhCZn.mjs").then((m) => m.initCommand),
+		projects: () => import("./projects-CN2YhCZn.mjs").then((m) => m.projectsCommand),
+		delete: () => import("./projects-CN2YhCZn.mjs").then((m) => m.deleteCommand),
+		dev: () => import("./dev-MoHHjQh1.mjs").then((m) => m.devCommand),
+		deploy: () => import("./deploy-Ka2lHkyy.mjs").then((m) => m.deployCommand),
+		promote: () => import("./deploy-Ka2lHkyy.mjs").then((m) => m.promoteCommand),
+		staging: () => import("./staging-BZVty57b.mjs").then((m) => m.stagingCommand),
+		rollback: () => import("./deploy-Ka2lHkyy.mjs").then((m) => m.rollbackCommand),
+		download: () => import("./deploy-Ka2lHkyy.mjs").then((m) => m.downloadCommand),
+		token: () => import("./token-HHlUR0CF.mjs").then((m) => m.tokenCommand),
+		egress: () => import("./egress-If_Gsx_M.mjs").then((m) => m.egressCommand),
+		secrets: () => import("./secrets-BSEjZnxg.mjs").then((m) => m.secretsCommand),
+		schedule: () => import("./schedule-C5lMf3ny.mjs").then((m) => m.scheduleCommand),
+		feedback: () => import("./feedback-_L3vqktY.mjs").then((m) => m.feedbackCommand),
+		db: () => import("./db-BB6O6085.mjs").then((m) => m.dbCommand),
+		usage: () => import("./usage-CUYrWxv0.mjs").then((m) => m.usageCommand),
+		ai: () => import("./ai-DHLnyqfq.mjs").then((m) => m.aiCommand),
+		open: () => import("./open-DcaQKi1v.mjs").then((m) => m.openCommand),
+		docs: () => import("./docs-CtNH5kbN.mjs").then((m) => m.docsCommand),
+		skill: () => import("./skill-CM7R-4Bq.mjs").then((m) => m.skillCommand),
+		upgrade: () => import("./upgrade-ChcSZW8i.mjs").then((m) => m.upgradeCommand),
+		logs: () => import("./logs-DQQOawOG.mjs").then((m) => m.logsCommand),
+		mcp: () => import("./mcp-RcN17Z2v.mjs").then((m) => m.mcpCommand)
 	}
 });
-if (process.argv[2] !== "upgrade") notifyOfUpdate(version);
-if (process.argv[2] && process.argv[2] !== "--help" && process.argv[2] !== "-h") console.error(siteHeaderLine(version));
+const quiet = process.argv[2] === "mcp" && process.argv[3] === "serve";
+if (process.argv[2] !== "upgrade" && !quiet) notifyOfUpdate(version);
+if (!quiet && process.argv[2] && process.argv[2] !== "--help" && process.argv[2] !== "-h") console.error(siteHeaderLine(version));
 await runMain(main);
 //#endregion
 export {};

package/dist/{local-BA_TPWpN.mjs → local-DAYCNUyz.mjs}

@@ -1,6 +1,6 @@
-import { s as apiDataRequest } from "./ui-CeupNHNa.mjs";
-import { a as META_COLUMNS, i as dbRouter, o as blobRouter, r as realtimeRouter } from "./src-C7zPhbxi.mjs";
-import { i as rewriteApiPath } from "./dev-JlzMZJow.mjs";
+import { n as apiDataRequest } from "./api-C4rMhE7i.mjs";
+import { a as dbRouter, i as realtimeRouter, o as META_COLUMNS, s as blobRouter } from "./src-BkACMkol.mjs";
+import { i as rewriteApiPath } from "./dev-CkhBnSlv.mjs";
 import { createRequire } from "node:module";
 import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { dirname, join, relative, sep } from "node:path";

package/dist/{login-MX0xq8UE.mjs → login-B-m-i8uu.mjs}

@@ -1,5 +1,5 @@
 import { _ as writeConfigFile, f as clearAllProfileTokens, g as upsertProfileAuth, h as setActiveProfile, m as readConfigFile, n as siteConfig, p as listBakedProfiles, v as getBakedProfile, y as isProfileId } from "./site-DM2J10CB.mjs";
-import { n as openBrowser, r as reportErrors } from "./ui-CeupNHNa.mjs";
+import { n as openBrowser, r as reportErrors } from "./ui-C_jSc1Kz.mjs";
 import { defineCommand } from "citty";
 import { hostname } from "node:os";
 import * as p from "@clack/prompts";

package/dist/{logs-D5RWqsWl.mjs → logs-DQQOawOG.mjs}

@@ -1,5 +1,6 @@
 import { c as resolveProject, o as projectFlagArgs } from "./site-DM2J10CB.mjs";
-import { d as withContext, l as apiRequest, r as reportErrors } from "./ui-CeupNHNa.mjs";
+import { i as apiRequest, o as withContext } from "./api-C4rMhE7i.mjs";
+import { r as reportErrors } from "./ui-C_jSc1Kz.mjs";
 import { defineCommand } from "citty";
 //#region src/logs.ts
 /**