@nearform/fling 0.8.0 → 0.9.0

package/dist/cli.js

@@ -2743,6 +2743,7 @@ function siteUrl(label, sitesDomain, protocol = "https:") {
 // ../../packages/shared/src/instance.ts
 import { z as z11 } from "zod";
 var INSTANCE_METADATA_PATH = "/.well-known/fling";
+var RELEASE_HEADER = "Fling-Release";
 var HEX_COLOR_RE = /^#(?:[0-9a-f]{3}|[0-9a-f]{6})$/i;
 var color = z11.string().regex(HEX_COLOR_RE);
 var SignInProviderSchema = z11.looseObject({
@@ -3294,7 +3295,7 @@ function mcpToolsFor(w) {
   const isPublic = z14.boolean().optional().describe(
     "Prefer `access` (a new site) or fling_set_access (an existing one). true \u2192 anyone can view; false \u2192 private. Omit to keep the current setting"
   );
-  const access2 = z14.enum(ACCESS_LEVELS).optional().describe(
+  const access3 = z14.enum(ACCESS_LEVELS).optional().describe(
     `Who can open a new site: only_me, members (${w.privateAudience}), groups, people or public. Ask the user before the first publish; omit for the default (${defaultAccessPhrase(w)}). Ignored when the site already exists`
   );
   const accessEmails = emails.optional().describe('With access "people" (or "groups"): the addresses that may open it');
@@ -3376,7 +3377,7 @@ function mcpToolsFor(w) {
         base,
         remove,
         spa,
-        access: access2,
+        access: access3,
         emails: accessEmails,
         groups: accessGroups,
         public: isPublic,
@@ -3397,7 +3398,7 @@ function mcpToolsFor(w) {
         base,
         remove,
         spa,
-        access: access2,
+        access: access3,
         emails: accessEmails,
         groups: accessGroups,
         public: isPublic
@@ -3921,7 +3922,7 @@ var LiveServerMessageSchema = z16.discriminatedUnion("type", [
 ]);
 
 // src/cli.ts
-import chalk14 from "chalk";
+import chalk15 from "chalk";
 import { Command, Option } from "commander";
 
 // src/commands/auth.ts
@@ -3971,7 +3972,7 @@ function exitCodeFor(error) {
 // package.json
 var package_default = {
   name: "@nearform/fling",
-  version: "0.8.0",
+  version: "0.9.0",
   license: "MIT",
   description: "Fling a folder of static files at a Fling server and get a link back. CLI + MCP server.",
   type: "module",
@@ -4025,6 +4026,7 @@ var package_default = {
 // src/package-info.ts
 var PACKAGE_NAME = package_default.name;
 var VERSION = package_default.version;
+var NODE_ENGINE = package_default.engines.node;
 var BIN_NAME = Object.keys(package_default.bin)[0] ?? "fling";
 var NPX_COMMAND = `npx ${package_default.name}`;
 
@@ -4066,6 +4068,14 @@ function createApiClient(options) {
   const serverUrl = options.serverUrl.replace(/\/+$/, "");
   const fetchImpl = options.fetch ?? ((input, init) => fetch(input, init));
   const timeoutMs = options.timeoutMs ?? 6e4;
+  let knownRelease = options.release;
+  async function noteRelease(response) {
+    const release = response.headers?.get?.(RELEASE_HEADER)?.trim();
+    if (!release || release.length > 64 || release === knownRelease) return;
+    knownRelease = release;
+    await options.onRelease?.(release).catch(() => {
+    });
+  }
   async function request(method, path3, reqOptions = {}) {
     const url = buildUrl(serverUrl, path3, reqOptions.query);
     const headers = {
@@ -4091,6 +4101,7 @@ function createApiClient(options) {
         cause
       });
     }
+    await noteRelease(response);
     const raw = await readBody(response);
     if (!response.ok) throw errorFromResponse(response.status, raw, method, path3);
     if (!reqOptions.schema) return raw;
@@ -4184,7 +4195,7 @@ function describeCause(cause) {
 // src/config.ts
 import { chmod, mkdir, readFile, stat, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
-import { join } from "node:path";
+import { delimiter, join } from "node:path";
 import { z as z17 } from "zod";
 var CONFIG_DIR_NAME = ".fling";
 var CONFIG_FILE_NAME = "config.json";
@@ -4196,7 +4207,11 @@ var ENV = {
   /** Where to look for files given by name (the .mcpb extension sets it from its settings). */
   downloadsDir: "FLING_DOWNLOADS_DIR",
   /** A server the local MCP server adds to the remembered ones on start (the .mcpb bakes it in). */
-  addServer: "FLING_ADD_SERVER"
+  addServer: "FLING_ADD_SERVER",
+  /** Set (to anything) to turn off the line saying a newer Fling release is out (update-check.ts). */
+  noUpdateCheck: "FLING_NO_UPDATE_CHECK",
+  /** Set by CI systems; the update check stays quiet there too. */
+  ci: "CI"
 };
 var serverEntrySchema = z17.object({
   /** What the server said about itself at login. A copy this CLI can't read is just refetched. */
@@ -4218,6 +4233,19 @@ function fromEnv(value) {
 function serverToAdd(env = process.env) {
   return fromEnv(env[ENV.addServer]);
 }
+function updateCheckSilenced(env = process.env) {
+  return Boolean(fromEnv(env[ENV.noUpdateCheck]) || fromEnv(env[ENV.ci]));
+}
+function envOverrides(env = process.env) {
+  return {
+    configDir: Boolean(env[ENV.configDir]),
+    url: Boolean(fromEnv(env[ENV.url])),
+    apiKey: Boolean(fromEnv(env[ENV.apiKey]))
+  };
+}
+function pathDirs(env = process.env) {
+  return (env.PATH ?? env.Path ?? "").split(delimiter).filter(Boolean);
+}
 function resolveConfigDir(env = process.env) {
   return env[ENV.configDir] ?? join(env.HOME ?? homedir(), CONFIG_DIR_NAME);
 }
@@ -4435,6 +4463,19 @@ async function loadInstanceWith(store, config, fetch2, capability) {
     return stored;
   }
 }
+async function recordRelease(store, serverUrl, release) {
+  const entry = (await store.load()).servers[serverUrl];
+  if (!entry?.instance || entry.instance.release === release) return;
+  await store.putServer(
+    serverUrl,
+    { instance: { ...entry.instance, release } },
+    { makeCurrent: false }
+  );
+}
+var releaseTracking = (store, config) => config.remembered && config.serverUrl ? {
+  release: config.instance?.release,
+  onRelease: (release) => recordRelease(store, config.serverUrl, release)
+} : {};
 
 // src/auth.ts
 var CALLBACK_PORT_START = 8765;
@@ -4830,7 +4871,9 @@ function requireClient(ctx) {
   return createApiClient({
     serverUrl,
     apiKey: ctx.config.apiKey,
-    fetch: ctx.fetch
+    fetch: ctx.fetch,
+    // A response saying the server runs another release updates the stored one.
+    ...ctx.store ? releaseTracking(ctx.store, ctx.config) : {}
   });
 }
 
@@ -4895,10 +4938,10 @@ async function setVisibility(client, name, visibility) {
   const raw = await client.request("PATCH", sitePath2(name), { body: { visibility } });
   return siteAfter(client, name, raw);
 }
-async function setAccess(client, name, access2, audience) {
+async function setAccess(client, name, access3, audience) {
   return client.request("PATCH", sitePath2(name), {
     schema: SiteWithAudienceSchema,
-    body: { access: access2, ...audience ? { audience } : {} }
+    body: { access: access3, ...audience ? { audience } : {} }
   });
 }
 function accessLevelsEnabled(instance) {
@@ -6714,10 +6757,804 @@ async function confirmSiteName(ctx, client, generated, base2) {
   }
 }
 
-// src/commands/forms.ts
-import { readFile as readFile8, stat as stat6, writeFile as writeFile4 } from "node:fs/promises";
-import { dirname as dirname3, join as join8, relative as relative5, resolve as resolve4 } from "node:path";
+// src/commands/doctor.ts
 import chalk8 from "chalk";
+
+// src/claude.ts
+import { execFile as execFile2 } from "node:child_process";
+import { access, mkdtemp as mkdtemp2, readFile as readFile8, writeFile as writeFile4 } from "node:fs/promises";
+import { homedir as homedir3, tmpdir as tmpdir2 } from "node:os";
+import { join as join8 } from "node:path";
+
+// mcpb/manifest.json
+var manifest_default = {
+  manifest_version: "0.3",
+  name: "fling",
+  display_name: "Fling",
+  version: "0.9.0",
+  description: "Publish HTML pages, zips and folders from your computer to Fling and get a link back.",
+  long_description: "Fling hosts static sites at https://<name>.<your sites domain> (private to people signed in to your Fling unless you make them public or share a link).\n\nThis extension runs on your computer, so Claude can publish:\n\n- content it created in the conversation (sent inline \u2014 no sandbox uploads),\n- a file you downloaded or Claude Desktop saved, by name: it looks in Downloads, Desktop, Documents/Claude and Claude Desktop's output folders,\n- a single .html file, a .zip of a site, or a folder with index.html.\n\nIt works with every Fling you sign in to: the one you downloaded it from is added on start, Claude can sign in to another with the fling_login tool, and the logins are shared with the fling CLI (`fling login <address>`). When several Flings are set up, Claude settles with you which one a conversation uses and names it on every call.",
+  author: {
+    name: "Fling contributors",
+    url: "https://github.com/nearform/fling"
+  },
+  repository: {
+    type: "git",
+    url: "https://github.com/nearform/fling.git"
+  },
+  homepage: "https://github.com/nearform/fling",
+  support: "https://github.com/nearform/fling/issues",
+  icon: "icon.png",
+  license: "MIT",
+  keywords: ["publish", "html", "static site", "hosting"],
+  server: {
+    type: "node",
+    entry_point: "server/index.mjs",
+    mcp_config: {
+      command: "node",
+      args: ["${__dirname}/server/index.mjs"],
+      env: {
+        FLING_DOWNLOADS_DIR: "${user_config.downloads_dir}"
+      }
+    }
+  },
+  tools: [
+    {
+      name: "fling_publish",
+      description: "Publish a site from files passed inline (content Claude created)"
+    },
+    {
+      name: "fling_deploy",
+      description: "Publish a file, zip or folder from this computer, found by name in Downloads and other folders"
+    },
+    {
+      name: "fling_pull",
+      description: "Download a site's files into a folder on this computer, to change them and deploy again"
+    },
+    {
+      name: "fling_read_files",
+      description: "Read a site's files inline, to change some and publish them with fling_publish"
+    },
+    {
+      name: "fling_find_files",
+      description: "List recent HTML files, zips and site folders on this computer"
+    },
+    { name: "fling_check_name", description: "Check whether a site name is free" },
+    { name: "fling_login", description: "Sign in to a Fling in the browser" },
+    {
+      name: "fling_servers",
+      description: "List the Flings set up on this computer, or switch the current one"
+    },
+    {
+      name: "fling_doctor",
+      description: "Check the Fling setup on this computer and say how to fix what is wrong"
+    },
+    { name: "fling_whoami", description: "Show the signed-in user" },
+    { name: "fling_list", description: "List your sites, or the sites shared with you" },
+    { name: "fling_info", description: "Show a site and its versions" },
+    { name: "fling_share", description: "Get, rotate or revoke a public share link" },
+    { name: "fling_set_visibility", description: "Make a site private or public" },
+    {
+      name: "fling_set_audience",
+      description: "Limit a private site to listed people and groups, or open it to everyone signed in"
+    },
+    { name: "fling_groups", description: "List the groups of people on a Fling" },
+    { name: "fling_group_show", description: "Show a group and its members" },
+    { name: "fling_group_create", description: "Create a group of people" },
+    {
+      name: "fling_group_members",
+      description: "Add people to a group you own, or take them out"
+    },
+    { name: "fling_group_rename", description: "Rename a group you own" },
+    { name: "fling_group_delete", description: "Delete a group you own" },
+    {
+      name: "fling_archive",
+      description: "Take a site offline (or restore it), keeping its files"
+    },
+    { name: "fling_rollback", description: "Serve an earlier version of a site" },
+    { name: "fling_delete", description: "Permanently delete a site" },
+    {
+      name: "fling_notifications",
+      description: "Show what a Fling emails you about"
+    },
+    {
+      name: "fling_notifications_set",
+      description: "Turn notifications on or off, per event or all at once"
+    }
+  ],
+  user_config: {
+    downloads_dir: {
+      type: "directory",
+      title: "Downloads folder",
+      description: "Where to look first for files you ask Claude to fling by name (Desktop, Documents/Claude and Claude Desktop output folders are searched too).",
+      default: "${HOME}/Downloads",
+      required: false
+    }
+  },
+  compatibility: {
+    platforms: ["darwin", "win32"],
+    runtimes: {
+      node: ">=20.0.0"
+    }
+  }
+};
+
+// src/claude.ts
+var MARKETPLACE_SOURCE = REPO_SLUG;
+var MARKETPLACE_NAME = "fling";
+var PLUGIN_NAME = "fling";
+var PLUGIN_ID = `${PLUGIN_NAME}@${MARKETPLACE_NAME}`;
+var MCPB_PATH = "/downloads/fling.mcpb";
+var runClaude = (args) => new Promise((resolve7) => {
+  execFile2(
+    "claude",
+    [...args],
+    { timeout: 12e4, maxBuffer: 16 * 1024 * 1024, shell: process.platform === "win32" },
+    (error, stdout, stderr) => {
+      const missing = error?.code === "ENOENT";
+      const code = !error ? 0 : missing ? -1 : typeof error.code === "number" ? error.code : 1;
+      resolve7({ code, stdout: String(stdout), stderr: String(stderr) });
+    }
+  );
+});
+async function claudeCodeStatus(run) {
+  const version = await run(["--version"]);
+  if (version.code !== 0) return { claude: "missing" };
+  const claude = version.stdout.trim().split(/\s+/)[0] ?? "unknown";
+  const list = await run(["plugin", "list", "--json"]);
+  let plugins = [];
+  try {
+    plugins = JSON.parse(list.stdout);
+  } catch {
+  }
+  const fling = Array.isArray(plugins) ? plugins.find((p) => p.id === PLUGIN_ID) : void 0;
+  if (!fling) return { claude, installed: false };
+  return {
+    claude,
+    installed: true,
+    version: fling.version,
+    scope: fling.scope,
+    enabled: fling.enabled
+  };
+}
+async function installPlugin(run, scope) {
+  check(
+    await run(["plugin", "install", PLUGIN_NAME, "--marketplace", MARKETPLACE_SOURCE, "-s", scope]),
+    "install the Fling plugin"
+  );
+}
+async function updatePlugin(run, scope) {
+  check(await run(["plugin", "marketplace", "update", MARKETPLACE_NAME]), "update the marketplace");
+  check(
+    await run(["plugin", "update", PLUGIN_ID, ...scope ? ["-s", scope] : []]),
+    "update the Fling plugin"
+  );
+}
+async function marketplaceConfigured(run) {
+  const list = await run(["plugin", "marketplace", "list", "--json"]);
+  if (list.code !== 0) return null;
+  try {
+    const marketplaces = JSON.parse(list.stdout);
+    return Array.isArray(marketplaces) && marketplaces.some((m) => m.name === MARKETPLACE_NAME);
+  } catch {
+    return null;
+  }
+}
+function check(result, what) {
+  if (result.code === 0) return;
+  const detail = (result.stderr || result.stdout).trim().split("\n").at(-1);
+  throw new Error(`Could not ${what}${detail ? `: ${detail}` : ""}`);
+}
+async function findClaudeDesktop(platform = process.platform, env = process.env, exists = (path3) => access(path3).then(
+  () => true,
+  () => false
+)) {
+  const candidates = platform === "darwin" ? ["/Applications/Claude.app", join8(homedir3(), "Applications", "Claude.app")] : platform === "win32" && env.LOCALAPPDATA ? [join8(env.LOCALAPPDATA, "AnthropicClaude"), join8(env.LOCALAPPDATA, "Programs", "Claude")] : [];
+  for (const path3 of candidates) if (await exists(path3)) return path3;
+  return null;
+}
+var DESKTOP_EXTENSION_ID = `local.mcpb.${manifest_default.author.name.toLowerCase().replace(/[^a-z0-9]+/g, "-")}.${manifest_default.name}`;
+function claudeDesktopDataDir(platform = process.platform, env = process.env, home = homedir3()) {
+  if (platform === "darwin") return join8(home, "Library", "Application Support", "Claude");
+  if (platform === "win32" && env.APPDATA) return join8(env.APPDATA, "Claude");
+  return null;
+}
+async function desktopExtensionStatus(dataDir) {
+  const readJson2 = async (path3) => {
+    try {
+      return JSON.parse(await readFile8(path3, "utf8"));
+    } catch {
+      return null;
+    }
+  };
+  const manifest = await readJson2(
+    join8(dataDir, "Claude Extensions", DESKTOP_EXTENSION_ID, "manifest.json")
+  );
+  if (!manifest) return { installed: false };
+  const settings = await readJson2(
+    join8(dataDir, "Claude Extensions Settings", `${DESKTOP_EXTENSION_ID}.json`)
+  );
+  return {
+    installed: true,
+    ...typeof manifest.version === "string" ? { version: manifest.version } : {},
+    ...typeof settings?.isEnabled === "boolean" ? { enabled: settings.isEnabled } : {}
+  };
+}
+var releaseExtensionUrl = (version) => `${REPO_URL}/releases/download/v${version}/fling.mcpb`;
+function extensionSources(serverUrl, serverRelease, version = VERSION) {
+  const server = {
+    url: new URL(MCPB_PATH, serverUrl).toString(),
+    ...serverRelease ? { version: serverRelease } : {}
+  };
+  if (serverRelease === version) return [server];
+  return [{ url: releaseExtensionUrl(version), version }, server];
+}
+async function downloadExtension(url, fetch2) {
+  const response = await fetch2(url);
+  if (!response.ok) throw new Error(`Could not download ${url} (HTTP ${response.status})`);
+  const dir = await mkdtemp2(join8(tmpdir2(), "fling-mcpb-"));
+  const file = join8(dir, "fling.mcpb");
+  await writeFile4(file, Buffer.from(await response.arrayBuffer()));
+  return file;
+}
+
+// src/doctor.ts
+import { execFile as execFile3 } from "node:child_process";
+import { access as access2, constants, realpath as realpath3, stat as stat6 } from "node:fs/promises";
+import { join as join10 } from "node:path";
+
+// src/update-check.ts
+import { mkdir as mkdir4, readFile as readFile9, writeFile as writeFile5 } from "node:fs/promises";
+import { join as join9 } from "node:path";
+var UPDATE_COMMAND = `npm i -g ${PACKAGE_NAME}@latest && ${BIN_NAME} setup`;
+var UPDATE_STATE_FILE = "update-check.json";
+var NOTIFY_EVERY_MS = 24 * 60 * 60 * 1e3;
+var SEMVER = /^v?(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z.-]+)?$/;
+function parseSemver(input) {
+  if (typeof input !== "string") return null;
+  const m = SEMVER.exec(input.trim());
+  if (!m) return null;
+  return { core: [Number(m[1]), Number(m[2]), Number(m[3])], pre: m[4] ? m[4].split(".") : [] };
+}
+function compareSemver(a, b) {
+  for (let i = 0; i < 3; i++) {
+    const d = (a.core[i] ?? 0) - (b.core[i] ?? 0);
+    if (d !== 0) return d;
+  }
+  if (!a.pre.length || !b.pre.length) return b.pre.length - a.pre.length;
+  for (let i = 0; i < Math.max(a.pre.length, b.pre.length); i++) {
+    const x = a.pre[i];
+    const y = b.pre[i];
+    if (x === void 0) return -1;
+    if (y === void 0) return 1;
+    if (x === y) continue;
+    const xn = /^\d+$/.test(x);
+    const yn = /^\d+$/.test(y);
+    if (xn && yn) return Number(x) - Number(y);
+    if (xn !== yn) return xn ? -1 : 1;
+    return x < y ? -1 : 1;
+  }
+  return 0;
+}
+function newerRelease(release, version = VERSION) {
+  const theirs = parseSemver(release);
+  const ours = parseSemver(version);
+  if (!theirs || !ours || compareSemver(theirs, ours) <= 0) return null;
+  return String(release).trim();
+}
+var updateLine = (release, version = VERSION) => `Fling ${release} is out (this CLI is ${version}). Update: ${UPDATE_COMMAND}`;
+var mcpUpdateNote = (release, version = VERSION) => `Fling ${release} is out and this Fling MCP server is ${version}. Tell the user once in this conversation, and suggest they update by running \`${UPDATE_COMMAND}\` in a terminal, then restarting Claude.`;
+async function updateNotice(input) {
+  try {
+    if (input.json || !input.stderrTTY || input.silenced || !input.serverUrl) return null;
+    const version = input.version ?? VERSION;
+    const release = newerRelease(input.release, version);
+    if (!release) return null;
+    const now = input.now ?? /* @__PURE__ */ new Date();
+    const file = join9(input.store.dir, UPDATE_STATE_FILE);
+    const state = await readState(file);
+    const last = Date.parse(state.notified[input.serverUrl] ?? "");
+    if (Number.isFinite(last) && now.getTime() - last < NOTIFY_EVERY_MS) return null;
+    state.notified[input.serverUrl] = now.toISOString();
+    await mkdir4(input.store.dir, { recursive: true, mode: 448 });
+    await writeFile5(file, `${JSON.stringify(state, null, 2)}
+`, { mode: 384 });
+    return updateLine(release, version);
+  } catch {
+    return null;
+  }
+}
+async function noticeAfterCommand(ctx, server, options = {}) {
+  try {
+    const config = await ctx.store.resolve({ serverUrl: server }).catch(() => ctx.config);
+    const line = await updateNotice({
+      store: ctx.store,
+      serverUrl: config.serverUrl,
+      release: config.instance?.release,
+      json: ctx.json,
+      stderrTTY: options.stderrTTY ?? Boolean(process.stderr.isTTY),
+      silenced: options.silenced ?? updateCheckSilenced(),
+      now: options.now,
+      version: options.version
+    });
+    if (line) ctx.log.warn(line);
+  } catch {
+  }
+}
+async function readState(file) {
+  try {
+    const json = JSON.parse(await readFile9(file, "utf8"));
+    const notified = json?.notified;
+    if (notified && typeof notified === "object" && !Array.isArray(notified)) {
+      const entries = Object.entries(notified).filter(
+        (e) => typeof e[1] === "string"
+      );
+      return { notified: Object.fromEntries(entries) };
+    }
+  } catch {
+  }
+  return { notified: {} };
+}
+
+// src/doctor.ts
+var NPM_DIST_TAGS_URL = `https://registry.npmjs.org/-/package/${PACKAGE_NAME.replace("/", "%2f")}/dist-tags`;
+var DEFAULT_TIMEOUT_MS = 5e3;
+var PLUGIN_UPDATE = `claude plugin marketplace update ${MARKETPLACE_NAME} && claude plugin update ${PLUGIN_ID}`;
+async function runChecks(deps) {
+  const timeoutMs = deps.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const fetchWithTimeout = (input, init) => deps.fetch(input, { ...init, signal: AbortSignal.timeout(timeoutMs) });
+  const d = { ...deps, fetch: fetchWithTimeout, timeoutMs, version: deps.version ?? VERSION };
+  const groups2 = await Promise.all([
+    cliChecks(d),
+    configChecks(d),
+    serverChecks(d),
+    claudeCodeChecks(d),
+    claudeDesktopChecks(d)
+  ]);
+  return groups2.flat();
+}
+var doctorExitCode = (checks) => checks.some((c) => c.status === "problem") ? 1 : 0;
+function systemDoctorDeps(store, fetch2, runClaude2, findClaudeDesktop2) {
+  const { env, home, platform } = systemLocateOptions();
+  return {
+    store,
+    fetch: fetch2,
+    env,
+    home,
+    platform,
+    runClaude: runClaude2,
+    findClaudeDesktop: findClaudeDesktop2,
+    runProgram: (file, args) => new Promise((resolve7) => {
+      execFile3(
+        file,
+        [...args],
+        { timeout: DEFAULT_TIMEOUT_MS, shell: platform === "win32" },
+        (error, stdout) => resolve7({ code: error ? 1 : 0, stdout: String(stdout) })
+      );
+    }),
+    selfPath: process.argv[1],
+    nodeVersion: process.versions.node
+  };
+}
+var SYMBOL = { ok: "\u2714", warning: "\u25B2", problem: "\u2716" };
+function describeChecks(checks) {
+  return checks.map((c) => `${SYMBOL[c.status]} ${c.message}${c.fix ? ` \u2014 fix: ${c.fix}` : ""}`).join("\n");
+}
+async function cliChecks(d) {
+  const checks = [
+    { area: "cli", id: "cli.version", status: "ok", message: `${BIN_NAME} CLI ${d.version}` }
+  ];
+  const min = minimumNode(NODE_ENGINE);
+  const node = parseSemver(d.nodeVersion);
+  if (min && node) {
+    checks.push(
+      compareSemver(node, min.semver) >= 0 ? { area: "cli", id: "cli.node", status: "ok", message: `Node.js ${d.nodeVersion}` } : {
+        area: "cli",
+        id: "cli.node",
+        status: "problem",
+        message: `Node.js ${d.nodeVersion} is too old: the CLI needs ${NODE_ENGINE}`,
+        fix: `Install Node.js ${min.text} or later (https://nodejs.org)`
+      }
+    );
+  }
+  const latest = await latestOnNpm(d);
+  if (latest) {
+    const newer = newerRelease(latest, d.version);
+    checks.push(
+      newer ? {
+        area: "cli",
+        id: "cli.latest",
+        status: "warning",
+        message: `${PACKAGE_NAME} ${newer} is on npm (this CLI is ${d.version})`,
+        fix: UPDATE_COMMAND
+      } : {
+        area: "cli",
+        id: "cli.latest",
+        status: "ok",
+        message: `Up to date with npm (latest: ${latest})`
+      }
+    );
+  }
+  checks.push(await onPath(d));
+  return checks;
+}
+function minimumNode(range) {
+  const m = /^>=\s*v?(\d+)(?:\.(\d+))?(?:\.(\d+))?$/.exec(range.trim());
+  if (!m) return null;
+  const text2 = [m[1], m[2], m[3]].filter((p) => p !== void 0).join(".");
+  const semver = parseSemver(`${m[1]}.${m[2] ?? 0}.${m[3] ?? 0}`);
+  return semver ? { text: text2, semver } : null;
+}
+async function latestOnNpm(d) {
+  try {
+    const response = await d.fetch(NPM_DIST_TAGS_URL, { headers: { Accept: "application/json" } });
+    if (!response.ok) return null;
+    const tags = await response.json();
+    return typeof tags.latest === "string" && parseSemver(tags.latest) ? tags.latest : null;
+  } catch {
+    return null;
+  }
+}
+async function onPath(d) {
+  const names = d.platform === "win32" ? [`${BIN_NAME}.cmd`, `${BIN_NAME}.exe`, BIN_NAME] : [BIN_NAME];
+  let found;
+  for (const dir of pathDirs(d.env)) {
+    for (const name of names) {
+      const path3 = join10(dir, name);
+      if (await isExecutable(path3, d.platform)) {
+        found = path3;
+        break;
+      }
+    }
+    if (found) break;
+  }
+  const install = `npm i -g ${PACKAGE_NAME}@latest`;
+  if (!found)
+    return {
+      area: "cli",
+      id: "cli.path",
+      status: "warning",
+      message: `\`${BIN_NAME}\` is not on your PATH (this CLI runs through npx or another path)`,
+      fix: install
+    };
+  const real = await realpath3(found).catch(() => found);
+  const self2 = d.selfPath ? await realpath3(d.selfPath).catch(() => d.selfPath) : void 0;
+  if (self2 && real === self2)
+    return {
+      area: "cli",
+      id: "cli.path",
+      status: "ok",
+      message: `\`${BIN_NAME}\` on PATH is this CLI (${found})`
+    };
+  const other = await d.runProgram(found, ["--version"]);
+  const version = other.code === 0 ? other.stdout.trim().split(/\s+/).at(-1) : void 0;
+  if (version === d.version)
+    return {
+      area: "cli",
+      id: "cli.path",
+      status: "ok",
+      message: `\`${BIN_NAME}\` on PATH (${found}) is ${version}, as this CLI`
+    };
+  return {
+    area: "cli",
+    id: "cli.path",
+    status: "warning",
+    message: `\`${BIN_NAME}\` on PATH (${found}) is ${version ? `version ${version}` : "another copy"}, not this CLI (${d.version})`,
+    fix: `${install} && ${BIN_NAME} setup`
+  };
+}
+async function isExecutable(path3, platform) {
+  try {
+    const s = await stat6(path3);
+    if (!s.isFile()) return false;
+    if (platform !== "win32") await access2(path3, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function configChecks(d) {
+  const overrides = envOverrides(d.env);
+  const checks = [];
+  const where = `${d.store.dir}${overrides.configDir ? ` (from ${ENV.configDir})` : ""}`;
+  const config = await d.store.load().catch(() => null);
+  const fileMode = await stat6(d.store.file).then(
+    (s) => s.mode & 511,
+    () => null
+  );
+  if (fileMode === null || !config || Object.keys(config.servers).length === 0) {
+    checks.push({
+      area: "config",
+      id: "config.dir",
+      status: "warning",
+      message: `No Fling is set up yet (config: ${where})`,
+      fix: `${BIN_NAME} setup <your Fling's address>`
+    });
+  } else {
+    checks.push({ area: "config", id: "config.dir", status: "ok", message: `Config: ${where}` });
+  }
+  if (fileMode !== null && d.platform !== "win32") {
+    const mode = fileMode.toString(8).padStart(3, "0");
+    checks.push(
+      fileMode & 63 ? {
+        area: "config",
+        id: "config.permissions",
+        status: "problem",
+        message: `${d.store.file} holds API keys and is readable by others (mode ${mode})`,
+        fix: `chmod 600 "${d.store.file}"`
+      } : {
+        area: "config",
+        id: "config.permissions",
+        status: "ok",
+        message: `The config file is private (mode ${mode})`
+      }
+    );
+  }
+  if (overrides.url)
+    checks.push({
+      area: "config",
+      id: "config.env.url",
+      status: "warning",
+      message: `${ENV.url} is set: commands use the server it names, not the current one`,
+      fix: `unset ${ENV.url} (if you did not mean to)`
+    });
+  if (overrides.apiKey)
+    checks.push({
+      area: "config",
+      id: "config.env.apiKey",
+      status: "warning",
+      message: `${ENV.apiKey} is set: commands use that key, not the stored one`,
+      fix: `unset ${ENV.apiKey} (if you did not mean to)`
+    });
+  return checks;
+}
+async function serverChecks(d) {
+  const config = await d.store.load().catch(() => null);
+  if (!config) return [];
+  const resolved = await d.store.resolve().catch(() => null);
+  const urls = Object.keys(config.servers);
+  if (resolved?.serverUrl && !urls.includes(resolved.serverUrl)) urls.push(resolved.serverUrl);
+  const perServer = await Promise.all(
+    urls.map(async (url) => {
+      const entry = config.servers[url] ?? {};
+      const label = `${url}${url === config.current ? " (current)" : ""}`;
+      const apiKey = resolved?.serverUrl === url && resolved.apiKeySource === "env" ? resolved.apiKey : entry.apiKey;
+      return oneServer(d, url, label, apiKey);
+    })
+  );
+  return perServer.flat();
+}
+async function oneServer(d, url, label, apiKey) {
+  const at = (id, check2) => ({
+    area: "server",
+    id,
+    server: url,
+    ...check2
+  });
+  let instance;
+  try {
+    instance = await fetchInstance(url, d.fetch);
+  } catch (error) {
+    return [
+      at("server.metadata", {
+        status: "problem",
+        message: `${label}: ${error.message}`,
+        fix: `Check the address and your connection; if the Fling moved: ${BIN_NAME} login <its new address>`
+      })
+    ];
+  }
+  const checks = [
+    at("server.metadata", { status: "ok", message: `${label}: ${instance.name} answers` })
+  ];
+  const newer = newerRelease(instance.release, d.version);
+  checks.push(
+    newer ? at("server.release", {
+      status: "warning",
+      message: `${label} runs Fling ${newer}, newer than this CLI (${d.version})`,
+      fix: UPDATE_COMMAND
+    }) : at("server.release", {
+      status: "ok",
+      message: instance.release ? `${label} runs Fling ${instance.release}` : `${label} does not say which release it runs`
+    })
+  );
+  const login = `${BIN_NAME} login ${url}`;
+  if (!apiKey) {
+    checks.push(
+      at("server.signedIn", { status: "problem", message: `${label}: not signed in`, fix: login })
+    );
+  } else {
+    try {
+      const client = createApiClient({
+        serverUrl: url,
+        apiKey,
+        fetch: d.fetch,
+        timeoutMs: d.timeoutMs
+      });
+      const me = await client.request("GET", "/api/me");
+      checks.push(
+        at("server.signedIn", {
+          status: "ok",
+          message: `${label}: signed in${me?.email ? ` as ${me.email}` : ""}`
+        })
+      );
+    } catch (error) {
+      checks.push(
+        exitCodeFor(error) === 2 ? at("server.signedIn", {
+          status: "problem",
+          message: `${label}: the API key is not accepted`,
+          fix: login
+        }) : at("server.signedIn", {
+          status: "warning",
+          message: `${label}: could not check the sign-in (${error.message})`,
+          fix: `${BIN_NAME} whoami --server ${url}`
+        })
+      );
+    }
+  }
+  const on = Object.entries(instance.capabilities).filter(([, v]) => v === true).map(([k]) => k).sort();
+  checks.push(
+    at("server.capabilities", {
+      status: "ok",
+      message: `${label}: ${on.length ? on.join(", ") : "no optional features"}`
+    })
+  );
+  return checks;
+}
+async function claudeCodeChecks(d) {
+  const status = await claudeCodeStatus(d.runClaude).catch(() => ({ claude: "missing" }));
+  if (status.claude === "missing")
+    return [
+      {
+        area: "claudeCode",
+        id: "claudeCode.cli",
+        status: "warning",
+        message: "Claude Code not found (no `claude` on your PATH)",
+        fix: `Install Claude Code (https://claude.com/claude-code), then run \`${BIN_NAME} setup\``
+      }
+    ];
+  const checks = [
+    {
+      area: "claudeCode",
+      id: "claudeCode.cli",
+      status: "ok",
+      message: `Claude Code ${status.claude}`
+    }
+  ];
+  const marketplace = await marketplaceConfigured(d.runClaude).catch(() => null);
+  if (marketplace === false)
+    checks.push({
+      area: "claudeCode",
+      id: "claudeCode.marketplace",
+      status: "warning",
+      message: `The ${MARKETPLACE_NAME} marketplace is not configured in Claude Code`,
+      fix: `${BIN_NAME} setup, or: claude plugin marketplace add ${MARKETPLACE_SOURCE}`
+    });
+  else if (marketplace === true)
+    checks.push({
+      area: "claudeCode",
+      id: "claudeCode.marketplace",
+      status: "ok",
+      message: `The ${MARKETPLACE_NAME} marketplace is configured`
+    });
+  if (!("installed" in status) || !status.installed) {
+    checks.push({
+      area: "claudeCode",
+      id: "claudeCode.plugin",
+      status: "warning",
+      message: "The Fling plugin is not installed in Claude Code",
+      fix: `${BIN_NAME} setup`
+    });
+    return checks;
+  }
+  if (status.enabled === false)
+    checks.push({
+      area: "claudeCode",
+      id: "claudeCode.enabled",
+      status: "problem",
+      message: "The Fling plugin is installed but disabled",
+      fix: `claude plugin enable ${PLUGIN_ID}`
+    });
+  const behind = status.version ? newerRelease(d.version, status.version) : null;
+  checks.push(
+    behind ? {
+      area: "claudeCode",
+      id: "claudeCode.plugin",
+      status: "warning",
+      message: `The Fling plugin is ${status.version}, older than this CLI (${d.version})`,
+      fix: `${BIN_NAME} setup, or: ${PLUGIN_UPDATE}`
+    } : {
+      area: "claudeCode",
+      id: "claudeCode.plugin",
+      status: "ok",
+      message: `The Fling plugin is installed${status.version ? ` (${status.version})` : ""}${status.enabled === false ? "" : " and enabled"}`
+    }
+  );
+  return checks;
+}
+async function claudeDesktopChecks(d) {
+  const app = await d.findClaudeDesktop().catch(() => null);
+  if (!app) return [];
+  const dataDir = claudeDesktopDataDir(d.platform, d.env, d.home);
+  const ext = dataDir ? await desktopExtensionStatus(dataDir) : null;
+  const at = (check2) => ({
+    area: "claudeDesktop",
+    id: "claudeDesktop.extension",
+    ...check2
+  });
+  if (!ext)
+    return [
+      at({
+        status: "ok",
+        message: `Claude Desktop is installed (${app}); the extension could not be looked up`
+      })
+    ];
+  if (!ext.installed)
+    return [
+      at({
+        status: "warning",
+        message: "The Fling extension is not installed in Claude Desktop",
+        fix: `${BIN_NAME} setup (it opens fling.mcpb in Claude Desktop)`
+      })
+    ];
+  const checks = [];
+  if (ext.enabled === false)
+    checks.push({
+      area: "claudeDesktop",
+      id: "claudeDesktop.enabled",
+      status: "problem",
+      message: "The Fling extension is installed in Claude Desktop but disabled",
+      fix: "Turn it on in Claude Desktop: Settings \u2192 Extensions \u2192 Fling"
+    });
+  const behind = ext.version ? newerRelease(d.version, ext.version) : null;
+  checks.push(
+    behind ? at({
+      status: "warning",
+      message: `The Claude Desktop extension is ${ext.version}, older than this CLI (${d.version})`,
+      fix: `${BIN_NAME} setup`
+    }) : at({
+      status: "ok",
+      message: `The Claude Desktop extension is installed${ext.version ? ` (${ext.version})` : ""} (${DESKTOP_EXTENSION_ID})`
+    })
+  );
+  return checks;
+}
+
+// src/commands/doctor.ts
+var AREAS = {
+  cli: "CLI",
+  config: "Config",
+  server: "Flings",
+  claudeCode: "Claude Code",
+  claudeDesktop: "Claude Desktop"
+};
+var SYMBOLS = { ok: symbols.success, warning: symbols.warn, problem: symbols.error };
+async function runDoctor(ctx, deps) {
+  const checks = await runChecks({
+    ...systemDoctorDeps(ctx.store, ctx.fetch, runClaude, () => findClaudeDesktop()),
+    ...deps
+  });
+  const ok = doctorExitCode(checks) === 0;
+  ctx.out.data({ ok, checks }, () => render(checks));
+  if (!ok) process.exitCode = 1;
+}
+function render(checks) {
+  const lines = [];
+  let area;
+  for (const c of checks) {
+    if (c.area !== area) {
+      area = c.area;
+      lines.push(`${lines.length ? "\n" : ""}${chalk8.bold(AREAS[c.area])}`);
+    }
+    const message = c.status === "problem" ? chalk8.red(c.message) : c.message;
+    lines.push(`${SYMBOLS[c.status]} ${message}${c.fix ? chalk8.dim(` \u2014 fix: ${c.fix}`) : ""}`);
+  }
+  return lines.join("\n");
+}
+
+// src/commands/forms.ts
+import { readFile as readFile10, stat as stat7, writeFile as writeFile6 } from "node:fs/promises";
+import { dirname as dirname3, join as join11, relative as relative5, resolve as resolve4 } from "node:path";
+import chalk9 from "chalk";
 async function formsClient(ctx) {
   const client = requireClient(ctx);
   const instance = await loadInstanceWith(ctx.store, ctx.config, ctx.fetch, "forms");
@@ -6746,8 +7583,8 @@ async function runForms(ctx, name, opts) {
   const summary = checkFormsConfig(forms2.config).summary;
   if (summary) {
     const lines = formsSummaryLines(summary);
-    const onPath = opts.path ? ` (on ${forms2.path ?? opts.path}: ${forms2.forms.map((f) => f.id).join(", ") || "none"})` : "";
-    ctx.log.info(`${summary.title} on ${name}${onPath}`);
+    const onPath2 = opts.path ? ` (on ${forms2.path ?? opts.path}: ${forms2.forms.map((f) => f.id).join(", ") || "none"})` : "";
+    ctx.log.info(`${summary.title} on ${name}${onPath2}`);
     for (const line of lines) ctx.log.hint(line);
   }
   if (instance)
@@ -6762,32 +7599,32 @@ async function runFormsInit(ctx, dir, opts) {
     });
   }
   const folder = resolve4(dir ?? ".");
-  const info = await stat6(folder).catch(() => null);
+  const info = await stat7(folder).catch(() => null);
   if (!info?.isDirectory()) throw new CliError(`No such folder: ${dir ?? "."}`);
-  const file = join8(folder, FORMS_FILE);
-  if (!opts.force && await stat6(file).catch(() => null)) {
+  const file = join11(folder, FORMS_FILE);
+  if (!opts.force && await stat7(file).catch(() => null)) {
     throw new CliError(`${shown(file)} already exists`, {
       hint: "Pass --force to replace it with the template."
     });
   }
   const config = formsTemplate(template, opts.title);
   requireValidForms(config, void 0, "The template", ctx.binName);
-  await writeFile4(file, `${formatJson(config)}
+  await writeFile6(file, `${formatJson(config)}
 `);
   ctx.log.success(`Wrote ${shown(file)} (${template}: ${FORM_TEMPLATE_DESCRIPTIONS[template]})`);
   ctx.out.data(
     { path: file, template, forms: config },
-    () => chalk8.dim(
+    () => chalk9.dim(
       `Change its options, wording and paths to fit, check it with \`${ctx.binName} forms check ${shown(dirname3(file))}\`, then deploy the folder.`
     )
   );
 }
 async function runFormsCheck(ctx, path3) {
   const target = resolve4(path3 ?? ".");
-  const info = await stat6(target).catch(() => null);
+  const info = await stat7(target).catch(() => null);
   if (!info) throw new CliError(`No such file or folder: ${path3 ?? "."}`);
   const folder = info.isDirectory() ? target : dirname3(target);
-  const file = info.isDirectory() ? join8(target, FORMS_FILE) : target;
+  const file = info.isDirectory() ? join11(target, FORMS_FILE) : target;
   const config = info.isDirectory() ? (await readFormsFile(folder))?.config : await readJson(file);
   if (config === void 0) {
     throw new CliError(`No ${FORMS_FILE} in ${shown(folder)}`, {
@@ -6808,7 +7645,7 @@ async function runFormsCheck(ctx, path3) {
 }
 async function readJson(file) {
   try {
-    return JSON.parse(await readFile8(file, "utf8"));
+    return JSON.parse(await readFile10(file, "utf8"));
   } catch (error) {
     throw new CliError(`${shown(file)} is not valid JSON: ${error.message}`);
   }
@@ -6828,7 +7665,7 @@ async function runResponses(ctx, name, opts) {
     const body = as === "csv" ? responsesCsv(exported.responses, exported.forms) : as === "jsonl" ? responsesJsonl(exported.responses) : `${formatJson(exported)}
 `;
     if (opts.output !== void 0) {
-      await writeFile4(resolve4(opts.output), body);
+      await writeFile6(resolve4(opts.output), body);
       ctx.log.success(
         `Wrote ${exported.responses.length} response${exported.responses.length === 1 ? "" : "s"} to ${shown(resolve4(opts.output))}`
       );
@@ -6836,7 +7673,7 @@ async function runResponses(ctx, name, opts) {
     return;
   }
   ctx.out.data({ ...exported, ...page ? { responsesUrl: page } : {} }, () => {
-    if (!exported.title) return chalk8.dim(`${name} has no forms on its live version.`);
+    if (!exported.title) return chalk9.dim(`${name} has no forms on its live version.`);
     const byId = new Map(exported.forms.map((f) => [f.id, f]));
     const table = renderTable(exported.responses, [
       { header: "PAGE", value: (r) => r.path },
@@ -6854,19 +7691,19 @@ async function runResponses(ctx, name, opts) {
       }
     ]);
     return [
-      chalk8.bold(`${exported.title} on ${name}`),
+      chalk9.bold(`${exported.title} on ${name}`),
       "",
       table,
       "",
-      ...progressLines(exported).map((l) => chalk8.dim(l)),
-      ...page ? [chalk8.dim(`Progress and downloads: ${page}`)] : [],
-      chalk8.dim(`Export: \`${ctx.binName} responses ${name} --format csv -o responses.csv\``)
+      ...progressLines(exported).map((l) => chalk9.dim(l)),
+      ...page ? [chalk9.dim(`Progress and downloads: ${page}`)] : [],
+      chalk9.dim(`Export: \`${ctx.binName} responses ${name} --format csv -o responses.csv\``)
     ].join("\n");
   });
 }
 
 // src/commands/groups.ts
-import chalk9 from "chalk";
+import chalk10 from "chalk";
 function requireGroups(ctx) {
   const instance = ctx.config.instance;
   if (instance && !groupsEnabled(instance)) throw new CliError(`${instance.name} has no groups`);
@@ -6887,7 +7724,7 @@ async function runGroups(ctx, opts) {
       { header: "NAME", value: (g) => g.name },
       { header: "PEOPLE", value: (g) => g.size },
       { header: "OWNER", value: (g) => g.owner === me.email ? "you" : g.owner }
-    ]) : chalk9.dim(members2 ? "No group has exactly those people." : describeGroups([]))
+    ]) : chalk10.dim(members2 ? "No group has exactly those people." : describeGroups([]))
   );
 }
 async function runGroupShow(ctx, slug) {
@@ -6933,7 +7770,7 @@ async function runGroupDelete(ctx, slug, opts) {
 }
 
 // src/commands/notifications.ts
-import chalk10 from "chalk";
+import chalk11 from "chalk";
 var VALUES = ["on", "off", "default"];
 function notificationsClient(ctx) {
   const instance = ctx.config.instance;
@@ -6956,10 +7793,10 @@ function renderSettings(settings) {
     })),
     { header: "WHEN", value: (e) => e.title }
   ]);
-  const lines = [table, "", chalk10.dim("* your choice; the rest are the defaults")];
+  const lines = [table, "", chalk11.dim("* your choice; the rest are the defaults")];
   if (settings.muted) {
     lines.unshift(
-      chalk10.yellow(
+      chalk11.yellow(
         "Muted: nothing is sent, whatever the table says (`fling notifications unmute` to undo)."
       ),
       ""
@@ -7018,13 +7855,13 @@ async function runNotificationsSent(ctx) {
       { header: "CHANNEL", value: (s) => s.channel },
       { header: "SUBJECT", value: (s) => s.subject },
       { header: "EVENTS", value: (s) => s.eventKeys.join(", ") }
-    ]) : chalk10.dim("Nothing was sent to you in the last 30 days.")
+    ]) : chalk11.dim("Nothing was sent to you in the last 30 days.")
   );
 }
 
 // src/commands/pull.ts
 import { relative as relative6, resolve as resolve5 } from "node:path";
-import chalk11 from "chalk";
+import chalk12 from "chalk";
 async function runPull(ctx, name, dir, opts) {
   const client = requireClient(ctx);
   const instance = await loadInstanceWith(ctx.store, ctx.config, ctx.fetch, "pull");
@@ -7066,11 +7903,11 @@ async function runPull(ctx, name, dir, opts) {
   });
   const shown2 = relative6(process.cwd(), pulled.dir) || ".";
   ctx.log.success(
-    `Pulled ${name}${path3 ? ` /${path3}/` : ""} into ${shown2} ${chalk11.dim(`(${pulled.fileCount} files, ${formatBytes(pulled.totalBytes)}, version ${pulled.versionId})`)}`
+    `Pulled ${name}${path3 ? ` /${path3}/` : ""} into ${shown2} ${chalk12.dim(`(${pulled.fileCount} files, ${formatBytes(pulled.totalBytes)}, version ${pulled.versionId})`)}`
   );
   ctx.out.data(
     pulled,
-    () => chalk11.dim(
+    () => chalk12.dim(
       `Change what you need, then \`${ctx.binName} deploy ${shown2}\`: it publishes on version ${pulled.versionId}, and stops if someone publishes ${name} before you do.`
     )
   );
@@ -7078,87 +7915,7 @@ async function runPull(ctx, name, dir, opts) {
 
 // src/commands/setup.ts
 import { intro, outro, spinner } from "@clack/prompts";
-import chalk12 from "chalk";
-
-// src/claude.ts
-import { execFile as execFile2 } from "node:child_process";
-import { access, mkdtemp as mkdtemp2, writeFile as writeFile5 } from "node:fs/promises";
-import { homedir as homedir3, tmpdir as tmpdir2 } from "node:os";
-import { join as join9 } from "node:path";
-var MARKETPLACE_SOURCE = REPO_SLUG;
-var MARKETPLACE_NAME = "fling";
-var PLUGIN_NAME = "fling";
-var PLUGIN_ID = `${PLUGIN_NAME}@${MARKETPLACE_NAME}`;
-var MCPB_PATH = "/downloads/fling.mcpb";
-var runClaude = (args) => new Promise((resolve7) => {
-  execFile2(
-    "claude",
-    [...args],
-    { timeout: 12e4, maxBuffer: 16 * 1024 * 1024, shell: process.platform === "win32" },
-    (error, stdout, stderr) => {
-      const missing = error?.code === "ENOENT";
-      const code = !error ? 0 : missing ? -1 : typeof error.code === "number" ? error.code : 1;
-      resolve7({ code, stdout: String(stdout), stderr: String(stderr) });
-    }
-  );
-});
-async function claudeCodeStatus(run) {
-  const version = await run(["--version"]);
-  if (version.code !== 0) return { claude: "missing" };
-  const claude = version.stdout.trim().split(/\s+/)[0] ?? "unknown";
-  const list = await run(["plugin", "list", "--json"]);
-  let plugins = [];
-  try {
-    plugins = JSON.parse(list.stdout);
-  } catch {
-  }
-  const fling = Array.isArray(plugins) ? plugins.find((p) => p.id === PLUGIN_ID) : void 0;
-  if (!fling) return { claude, installed: false };
-  return {
-    claude,
-    installed: true,
-    version: fling.version,
-    scope: fling.scope,
-    enabled: fling.enabled
-  };
-}
-async function installPlugin(run, scope) {
-  check(
-    await run(["plugin", "install", PLUGIN_NAME, "--marketplace", MARKETPLACE_SOURCE, "-s", scope]),
-    "install the Fling plugin"
-  );
-}
-async function updatePlugin(run, scope) {
-  check(await run(["plugin", "marketplace", "update", MARKETPLACE_NAME]), "update the marketplace");
-  check(
-    await run(["plugin", "update", PLUGIN_ID, ...scope ? ["-s", scope] : []]),
-    "update the Fling plugin"
-  );
-}
-function check(result, what) {
-  if (result.code === 0) return;
-  const detail = (result.stderr || result.stdout).trim().split("\n").at(-1);
-  throw new Error(`Could not ${what}${detail ? `: ${detail}` : ""}`);
-}
-async function findClaudeDesktop(platform = process.platform, env = process.env, exists = (path3) => access(path3).then(
-  () => true,
-  () => false
-)) {
-  const candidates = platform === "darwin" ? ["/Applications/Claude.app", join9(homedir3(), "Applications", "Claude.app")] : platform === "win32" && env.LOCALAPPDATA ? [join9(env.LOCALAPPDATA, "AnthropicClaude"), join9(env.LOCALAPPDATA, "Programs", "Claude")] : [];
-  for (const path3 of candidates) if (await exists(path3)) return path3;
-  return null;
-}
-async function downloadExtension(serverUrl, fetch2) {
-  const url = new URL(MCPB_PATH, serverUrl).toString();
-  const response = await fetch2(url);
-  if (!response.ok) throw new Error(`Could not download ${url} (HTTP ${response.status})`);
-  const dir = await mkdtemp2(join9(tmpdir2(), "fling-mcpb-"));
-  const file = join9(dir, "fling.mcpb");
-  await writeFile5(file, Buffer.from(await response.arrayBuffer()));
-  return file;
-}
-
-// src/commands/setup.ts
+import chalk13 from "chalk";
 var SCOPES = ["user", "project", "local"];
 async function runSetup(baseCtx, opts, deps = {}) {
   const scope = opts.scope ?? "user";
@@ -7171,14 +7928,14 @@ async function runSetup(baseCtx, opts, deps = {}) {
     ...baseCtx,
     log: createLogger({
       debug: baseCtx.config.debug,
-      write: (line) => process.stderr.write(`${chalk12.gray("\u2502")}  ${line}
+      write: (line) => process.stderr.write(`${chalk13.gray("\u2502")}  ${line}
 `)
     })
   } : baseCtx;
   if (fancy) {
     process.stderr.write(`${logo()}
 `);
-    intro(chalk12.bold(" fling setup "), { output: process.stderr });
+    intro(chalk13.bold(" fling setup "), { output: process.stderr });
   }
   const login = await stepLogin(ctx, opts.url);
   const results = {
@@ -7192,7 +7949,7 @@ async function runSetup(baseCtx, opts, deps = {}) {
   const failed = Object.values(results).includes("failed");
   if (fancy)
     outro(
-      failed ? chalk12.yellow("Setup finished with problems \u2014 see above, then run `fling setup` again.") : `You're set. Try ${chalk12.bold(`${ctx.binName} deploy ./dist`)}, or ask Claude to \u201Cfling this\u201D.`,
+      failed ? chalk13.yellow("Setup finished with problems \u2014 see above, then run `fling setup` again.") : `You're set. Try ${chalk13.bold(`${ctx.binName} deploy ./dist`)}, or ask Claude to \u201Cfling this\u201D.`,
       { output: process.stderr }
     );
   ctx.out.data(results, () => "");
@@ -7215,7 +7972,10 @@ async function signIn(ctx, serverUrl) {
     try {
       const me = await whoami(requireClient(ctx));
       if (ctx.config.remembered) await ctx.store.setCurrent(serverUrl);
-      ctx.log.success(`Signed in as ${chalk12.bold(me.name)} ${chalk12.dim(`<${me.email}>`)}`);
+      ctx.log.success(`Signed in as ${chalk13.bold(me.name)} ${chalk13.dim(`<${me.email}>`)}`);
+      if (ctx.config.remembered)
+        await fetchInstance(serverUrl, ctx.fetch).then((instance) => ctx.store.putServer(serverUrl, { instance }, { makeCurrent: false })).catch(() => {
+        });
       return "already";
     } catch (error) {
       if (exitCodeFor(error) !== 2) {
@@ -7236,48 +7996,80 @@ async function signIn(ctx, serverUrl) {
 async function stepClaudeCode(ctx, run, scope, ask, fancy) {
   const status = await claudeCodeStatus(run);
   if (status.claude === "missing") {
-    ctx.log.info(`Claude Code not found ${chalk12.dim("(no `claude` on your PATH) \u2014 skipped")}`);
+    ctx.log.info(`Claude Code not found ${chalk13.dim("(no `claude` on your PATH) \u2014 skipped")}`);
     ctx.log.hint(
       `Once it is installed, run \`${ctx.binName} setup\` again, or in Claude Code: /plugin marketplace add ${MARKETPLACE_SOURCE} then /plugin install ${PLUGIN_ID}`
     );
     return "missing";
   }
-  const installed = "installed" in status && status.installed;
-  const question = installed ? `The Fling plugin is installed in Claude Code${status.version ? ` (${status.version})` : ""}. Update it to the latest?` : "Install the Fling plugin (skill + MCP server) into Claude Code?";
-  if (ask && !await ctx.confirm(question)) {
-    ctx.log.info(chalk12.dim("Claude Code plugin: skipped"));
-    return installed ? "already" : "skipped";
+  if ("installed" in status && status.installed) return refreshPlugin(ctx, run, status, fancy);
+  if (ask && !await ctx.confirm("Install the Fling plugin (skill + MCP server) into Claude Code?")) {
+    ctx.log.info(chalk13.dim("Claude Code plugin: skipped"));
+    return "skipped";
   }
   const s = fancy ? spinner({ output: process.stderr }) : null;
-  s?.start(installed ? "Updating the Claude Code plugin" : "Installing the Claude Code plugin");
+  s?.start("Installing the Claude Code plugin");
   try {
-    if (installed) await updatePlugin(run, status.scope);
-    else await installPlugin(run, scope);
+    await installPlugin(run, scope);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     if (s) s.error(message);
     else ctx.log.error(message);
     return "failed";
   }
-  const done = installed ? `Claude Code plugin ${PLUGIN_NAME} is up to date` : `Claude Code plugin ${PLUGIN_NAME} installed ${chalk12.dim(`(${scope} scope)`)}`;
+  const done = `Claude Code plugin ${PLUGIN_NAME} installed ${chalk13.dim(`(${scope} scope)`)}`;
   if (s) s.stop(done);
   else ctx.log.success(done);
   ctx.log.hint("Restart Claude Code (or run /reload-plugins) to pick it up.");
-  return installed ? "updated" : "done";
+  return "done";
+}
+async function refreshPlugin(ctx, run, before, fancy) {
+  const s = fancy ? spinner({ output: process.stderr }) : null;
+  s?.start("Updating the Claude Code plugin");
+  try {
+    await updatePlugin(run, before.scope);
+  } catch (error) {
+    const message = `${error instanceof Error ? error.message : String(error)} \u2014 the installed plugin${before.version ? ` (${before.version})` : ""} is unchanged`;
+    if (s) s.stop(chalk13.yellow(message));
+    else ctx.log.warn(message);
+    return "already";
+  }
+  const after = await claudeCodeStatus(run).catch(() => null);
+  const version = after && "installed" in after && after.installed ? after.version : void 0;
+  const unchanged = before.version !== void 0 && version === before.version;
+  const done = unchanged ? `Claude Code plugin ${PLUGIN_NAME} is up to date ${chalk13.dim(`(${version})`)}` : before.version && version ? `Claude Code plugin ${PLUGIN_NAME} updated from ${before.version} to ${version}` : `Claude Code plugin ${PLUGIN_NAME} updated${version ? ` to ${version}` : ""}`;
+  if (s) s.stop(done);
+  else ctx.log.success(done);
+  if (unchanged) return "already";
+  ctx.log.hint("Restart Claude Code (or run /reload-plugins) to pick up the new version.");
+  return "updated";
 }
 async function stepClaudeDesktop(ctx, deps, ask, fancy) {
   const app = await (deps.findClaudeDesktop ?? findClaudeDesktop)();
   if (!app) return "missing";
   if (ask && !await ctx.confirm("Add the Fling extension to Claude Desktop too?")) {
-    ctx.log.info(chalk12.dim("Claude Desktop extension: skipped"));
+    ctx.log.info(chalk13.dim("Claude Desktop extension: skipped"));
     return "skipped";
   }
   const s = fancy ? spinner({ output: process.stderr }) : null;
   s?.start("Downloading the Claude Desktop extension");
+  const download2 = deps.downloadExtension ?? ((url) => downloadExtension(url, ctx.fetch));
   try {
-    const file = await (deps.downloadExtension ?? ((serverUrl) => downloadExtension(serverUrl, ctx.fetch)))(requireServer(ctx));
-    await ctx.open(file);
-    const done = "Opened fling.mcpb in Claude Desktop \u2014 click Install there to finish";
+    const sources = extensionSources(requireServer(ctx), ctx.config.instance?.release);
+    let got;
+    let lastError;
+    for (const source of sources) {
+      try {
+        got = { file: await download2(source.url), version: source.version };
+        break;
+      } catch (error) {
+        lastError = error;
+        ctx.log.debug(`Could not download ${source.url}: ${String(error)}`);
+      }
+    }
+    if (!got) throw lastError;
+    await ctx.open(got.file);
+    const done = `Opened fling.mcpb${got.version ? ` ${got.version}` : ""} in Claude Desktop \u2014 click Install there to finish (it replaces an older version)`;
     if (s) s.stop(done);
     else ctx.log.success(done);
     return "done";
@@ -7290,7 +8082,7 @@ async function stepClaudeDesktop(ctx, deps, ask, fancy) {
 }
 
 // src/commands/sites.ts
-import chalk13 from "chalk";
+import chalk14 from "chalk";
 async function runList(ctx, opts) {
   const sites = await listSites(requireClient(ctx), opts);
   ctx.out.data(
@@ -7326,12 +8118,12 @@ async function runListShared(ctx, opts) {
   );
 }
 var accessLabel = (site) => ACCESS_LABELS[siteAccessLevel(site)];
-var row = (label, value) => `${chalk13.bold(`${label}:`.padEnd(14))}${value}`;
+var row = (label, value) => `${chalk14.bold(`${label}:`.padEnd(14))}${value}`;
 function describeSite(site) {
   return [
     row("Name", site.name),
     row("URL", site.url),
-    row("Access", accessLabel(site) + (site.archived ? chalk13.yellow(" (archived)") : "")),
+    row("Access", accessLabel(site) + (site.archived ? chalk14.yellow(" (archived)") : "")),
     row("SPA", site.spa ? "yes" : "no"),
     row("Share link", site.shareUrl ?? "-"),
     row("Version", site.currentVersionId ?? "-"),
@@ -7360,15 +8152,15 @@ function filesRow(site) {
 var membersOf = (ctx) => ctx.config.instance ? privateAudience(ctx.config.instance) : "anyone signed in to this Fling";
 async function runInfo(ctx, name) {
   const site = await getSite(requireClient(ctx), name);
-  const access2 = site.audience && audiencesEnabled(ctx.config.instance) ? [`${chalk13.bold("Who:".padEnd(14))}${describeAudience(site, membersOf(ctx))}`] : [];
+  const access3 = site.audience && audiencesEnabled(ctx.config.instance) ? [`${chalk14.bold("Who:".padEnd(14))}${describeAudience(site, membersOf(ctx))}`] : [];
   ctx.out.data(
     site,
     () => [
       ...describeSite(site),
-      ...access2,
+      ...access3,
       ...rolesRows(site),
       "",
-      chalk13.dim(
+      chalk14.dim(
         `${site.versions.length} version(s) \u2014 \`fling versions ${name}\`; files \u2014 \`fling files ${name}\``
       )
     ].join("\n")
@@ -7396,7 +8188,7 @@ async function runFiles(ctx, name, versionId) {
   }
   ctx.out.data(result, () => {
     const n = result.files.length;
-    const header = chalk13.dim(
+    const header = chalk14.dim(
       `${result.versionId}${result.current ? " (current)" : " (not served)"} \u2014 ${n} file${n === 1 ? "" : "s"}, ${formatBytes(result.totalBytes)}${result.generatedIndex ? ", generated index.html" : ""}`
     );
     const table = renderTable(result.files, [
@@ -7432,7 +8224,7 @@ async function runShare(ctx, name, opts) {
     ctx.log.success("Share link created \u2014 anyone with it can view the site");
   ctx.out.data(
     ready === void 0 ? result : { ...result, ready },
-    () => result.shareUrl ? result.shareUrl : chalk13.dim("(no share link)")
+    () => result.shareUrl ? result.shareUrl : chalk14.dim("(no share link)")
   );
 }
 async function runVisibility(ctx, name, visibility) {
@@ -7544,15 +8336,15 @@ async function runRemove(ctx, name, opts) {
 }
 
 // src/mcp.ts
-import { mkdir as mkdir4, mkdtemp as mkdtemp3, rm as rm3, writeFile as writeFile6 } from "node:fs/promises";
+import { mkdir as mkdir5, mkdtemp as mkdtemp3, rm as rm3, writeFile as writeFile7 } from "node:fs/promises";
 import { tmpdir as tmpdir3 } from "node:os";
-import { basename as basename3, dirname as dirname4, join as join10, resolve as resolvePath } from "node:path";
+import { basename as basename3, dirname as dirname4, join as join12, resolve as resolvePath } from "node:path";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z as z20 } from "zod";
 
 // src/locate.ts
-import { lstat, readdir as readdir3, readFile as readFile9, realpath as realpath3, stat as stat7 } from "node:fs/promises";
+import { lstat, readdir as readdir3, readFile as readFile11, realpath as realpath4, stat as stat8 } from "node:fs/promises";
 import { posix, win32 } from "node:path";
 import { fileURLToPath } from "node:url";
 var DOWNLOADS_DIR_ENV = "FLING_DOWNLOADS_DIR";
@@ -7565,7 +8357,7 @@ var SANDBOX_PATH_RE = /^\/(mnt\/user-data|mnt\/data|sessions|home\/claude|tmp\/o
 var nodeFs = {
   async stat(path3) {
     try {
-      const s = await stat7(path3);
+      const s = await stat8(path3);
       return { isFile: s.isFile(), isDirectory: s.isDirectory(), mtimeMs: s.mtimeMs, size: s.size };
     } catch {
       return null;
@@ -7577,7 +8369,7 @@ var nodeFs = {
       const out = [];
       for (const e of entries) {
         if (e.isSymbolicLink()) {
-          const s = await stat7(`${path3}/${e.name}`).catch(() => null);
+          const s = await stat8(`${path3}/${e.name}`).catch(() => null);
           out.push({ name: e.name, isFile: Boolean(s?.isFile()), isDirectory: false });
         } else out.push({ name: e.name, isFile: e.isFile(), isDirectory: e.isDirectory() });
       }
@@ -7587,12 +8379,12 @@ var nodeFs = {
     }
   },
   async realpath(path3) {
-    return realpath3(path3).catch(() => null);
+    return realpath4(path3).catch(() => null);
   },
   async readText(path3) {
     try {
       if (!(await lstat(path3)).isFile()) return null;
-      return await readFile9(path3, "utf8");
+      return await readFile11(path3, "utf8");
     } catch {
       return null;
     }
@@ -7964,6 +8756,7 @@ var LOGIN_HINT = `Not logged in to Fling. Call fling_login (it opens the browser
 var NO_SERVER_HINT = `No Fling server is set up on this computer. Ask the user for their Fling's address, then call fling_login with it as \`server\` (or ask them to run \`${NPX_COMMAND} login <url>\` in a terminal; in Claude Code: \`! ${NPX_COMMAND} login <url>\`), then try again.`;
 var mcpLocalInstructions = (w, opts = {}) => [
   `${w.name} publishes static sites (HTML/CSS/JS, images, documents) at ${w.sitesPattern}. This server runs on the user's computer.`,
+  ...opts.newerRelease ? [mcpUpdateNote(opts.newerRelease)] : [],
   ...[serversInstructions(opts.servers ?? [])].filter((p) => p !== void 0),
   "Content you created in this conversation (an HTML page, a report, a small app): call fling_publish with every file inline (text as utf8, binary as base64). Never pass file paths from your sandbox (e.g. /mnt/user-data/outputs/\u2026, /sessions/\u2026) \u2014 this computer cannot see them \u2014 and never curl or upload from the sandbox.",
   'A file or folder the user has on this computer (a downloaded .html, a .zip, a build folder): call fling_deploy with its path, or just its file name (e.g. "Pitch Deck.html") \u2014 it is looked up in Downloads, Desktop, Documents/Claude and Claude Desktop output folders. Use fling_find_files to see recent candidates when unsure which file the user means.',
@@ -7979,6 +8772,14 @@ var mcpLocalInstructions = (w, opts = {}) => [
   ] : [],
   ...opts.notifications ? [NOTIFICATIONS_NOTE(w)] : []
 ].join("\n\n");
+var PUBLISHING_TOOLS = /* @__PURE__ */ new Set(["fling_publish", "fling_deploy"]);
+function newestRelease(servers) {
+  const newer = servers.map((s) => newerRelease(s.instance?.release)).filter((r) => r !== null);
+  return newer.reduce(
+    (best, r) => best && newerRelease(r, best) === null ? best : r,
+    null
+  );
+}
 var onFling = (url, instance) => `
 Fling: ${serverLabel(url)}${instance ? ` (${instance.name})` : ""}`;
 function createMcpServer(deps = {}) {
@@ -8025,7 +8826,12 @@ Not reachable yet at ${url}: ${NOT_READY_NOTE}.`
     const url = config.serverUrl;
     let instance;
     return {
-      client: createApiClient({ serverUrl: url, apiKey: config.apiKey, fetch: fetchImpl }),
+      client: createApiClient({
+        serverUrl: url,
+        apiKey: config.apiKey,
+        fetch: fetchImpl,
+        ...releaseTracking(store, config)
+      }),
       url,
       config,
       instance: () => {
@@ -8086,10 +8892,24 @@ Not reachable yet at ${url}: ${NOT_READY_NOTE}.`
       return void 0;
     }
   }
+  let updateNoted = false;
+  async function updateNoteFor(t2) {
+    if (updateNoted) return "";
+    const stored = await store.resolve({ serverUrl: t2.url }).catch(() => null);
+    const release = newerRelease(
+      (stored?.instance ?? await t2.instance().catch(() => null))?.release
+    );
+    if (!release) return "";
+    updateNoted = true;
+    return `
+${mcpUpdateNote(release)}`;
+  }
   async function run(tool2, server2, op) {
     try {
-      const { summary, data } = await op(await target(server2, tool2));
-      return textResult(`${summary}
+      const t2 = await target(server2, tool2);
+      const { summary, data } = await op(t2);
+      const update = PUBLISHING_TOOLS.has(tool2) ? await updateNoteFor(t2) : "";
+      return textResult(`${summary}${update}
 
 ${JSON.stringify(data, null, 2)}`);
     } catch (error) {
@@ -8205,12 +9025,12 @@ ${describeFormsSummary(formsSummary, responsesPage)}` : "";
 ${shareForFeedback(review, instance?.name ?? "Fling", formsSummary !== null)}
 Site: ${url} (${level})${formsText}` : `${what}: ${url} (${level})${listing2}${formsText}`;
     const who = describeSiteAccess(result.site, await membersOn(t2));
-    const access3 = result.first ? `
+    const access4 = result.first ? `
 Who can open it: ${who} ${accessChangeHint("mcp", result.name, { invites: instance?.capabilities.invites === true })}` : opts.access ? `
 Its access is unchanged (deploying never changes it for an existing site): ${who} ${accessChangeHint("mcp", result.name, { invites: instance?.capabilities.invites === true })}` : "";
     return {
       kind: "deployed",
-      summary: `${head}${access3}${warnings}${skippedNote}${edge.note}${onFling(t2.url, instance)}
+      summary: `${head}${access4}${warnings}${skippedNote}${edge.note}${onFling(t2.url, instance)}
 To check exactly which files the site has, call fling_files with name "${result.name}".` + (formsHint2 ? `
 ${formsHint2}` : ""),
       data: {
@@ -8247,7 +9067,8 @@ ${formsHint2}` : ""),
         comments: servers.some((s) => commentsEnabled(s.instance)),
         forms: servers.some((s) => formsEnabled(s.instance)),
         notifications: servers.some((s) => notificationsEnabled(s.instance)),
-        servers
+        servers,
+        newerRelease: newestRelease(servers)
       })
     }
   );
@@ -8255,7 +9076,7 @@ ${formsHint2}` : ""),
     listHtml: listHtml2,
     spa: spa2,
     public: isPublic,
-    access: access2,
+    access: access3,
     emails: emails2,
     groups: groups2,
     forms: formsArg
@@ -8276,7 +9097,7 @@ ${formsHint2}` : ""),
           'Publish into this folder of the site only, e.g. "30-10-26" (served at <site>/30-10-26/), keeping every other file of the site. Needs `name`. Omit to replace the whole site'
         ),
         spa: spa2,
-        access: access2,
+        access: access3,
         emails: emails2,
         groups: groups2,
         public: isPublic,
@@ -8366,7 +9187,7 @@ ${formsHint2}` : ""),
           `Invalid path "${args.path}": use a folder of the site, like "30-10-26" (no dotfiles)`
         );
       }
-      const dir = args.dir === void 0 ? join10(locate.home, "Documents", "Claude", "fling", args.name) : resolvePath(cwd, args.dir);
+      const dir = args.dir === void 0 ? join12(locate.home, "Documents", "Claude", "fling", args.name) : resolvePath(cwd, args.dir);
       const pulled = await pullSite(
         { client: t2.client, fetch: fetchImpl },
         {
@@ -8472,7 +9293,7 @@ ${JSON.stringify(data, null, 2)}`);
       }
       if (args.files.length === 0 && !args.remove?.length)
         throw new CliError("No files to publish");
-      const tmp = await mkdtemp3(join10(tmpdir3(), "fling-publish-"));
+      const tmp = await mkdtemp3(join12(tmpdir3(), "fling-publish-"));
       try {
         const { skippedDotfiles } = await writeInlineFiles(tmp, args.files);
         return await deployFolder(t2, tmp, {
@@ -8621,6 +9442,29 @@ ${known.join("\n")}` : ""
       }
     }
   );
+  server.registerTool(
+    "fling_doctor",
+    {
+      title: "Check this computer's Fling setup",
+      description: "Diagnose Fling on the user's computer, read-only: the CLI's version (and the latest on npm), Node.js, the config, each Fling set up here (reachable, its release, whether the sign-in still works, its features), the Claude Code plugin and the Claude Desktop extension. One line per check (\u2714 ok, \u25B2 warning, \u2716 problem), each warning and problem with its fix. Call it when something about Fling does not work (sign-in, tools missing, versions), then tell the user the fixes; never run them for the user without asking.",
+      inputSchema: {},
+      annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true }
+    },
+    async () => {
+      try {
+        const checks = await runChecks({
+          ...systemDoctorDeps(store, fetchImpl, runClaude, () => findClaudeDesktop()),
+          ...deps.doctor
+        });
+        const ok = doctorExitCode(checks) === 0;
+        return textResult(`${describeChecks(checks)}
+
+${JSON.stringify({ ok, checks }, null, 2)}`);
+      } catch (error) {
+        return failure(error);
+      }
+    }
+  );
   server.registerTool(
     "fling_servers",
     {
@@ -8697,7 +9541,7 @@ ${lines}` : ""}`,
     serverTool(t.info),
     (args) => run(t.info.name, args.server, async (target2) => {
       const site = await getSite(target2.client, args.name);
-      const access3 = site.audience ? `
+      const access4 = site.audience ? `
 ${describeAudience(site, await membersOn(target2))}` : "";
       const current = site.versions.find((v) => v.id === site.currentVersionId);
       const by = current?.publishedBy ? ` by ${current.publishedBy}` : "";
@@ -8706,7 +9550,7 @@ ${describeAudience(site, await membersOn(target2))}` : "";
 Current version published${by}${to}` : "";
       const roles = site.owners ? `
 ${describeRoles(site)}` : "";
-      return { summary: `${site.name}: ${site.url}${access3}${roles}${published}`, data: site };
+      return { summary: `${site.name}: ${site.url}${access4}${roles}${published}`, data: site };
     })
   );
   server.registerTool(
@@ -9204,9 +10048,9 @@ async function writeInlineFiles(dir, files) {
     total += bytes.length;
     if (total > MAX_DEPLOY_BYTES)
       throw new CliError(`The site is larger than ${formatBytes(MAX_DEPLOY_BYTES)}`);
-    const target = join10(dir, ...path3.split("/"));
-    await mkdir4(dirname4(target), { recursive: true });
-    await writeFile6(target, bytes);
+    const target = join12(dir, ...path3.split("/"));
+    await mkdir5(dirname4(target), { recursive: true });
+    await writeFile7(target, bytes);
   }
   if (secretFiles.length > 0) throw new SecretFilesError(secretFiles);
   return { skippedDotfiles };
@@ -9250,10 +10094,10 @@ async function runMcpServer(deps = {}) {
 }
 
 // src/route.ts
-import { stat as stat8 } from "node:fs/promises";
+import { stat as stat9 } from "node:fs/promises";
 import { resolve as resolve6 } from "node:path";
 var PASS_THROUGH = /* @__PURE__ */ new Set(["-h", "--help", "-V", "--version"]);
-var pathExists = (path3) => stat8(resolve6(path3)).then(
+var pathExists = (path3) => stat9(resolve6(path3)).then(
   () => true,
   () => false
 );
@@ -9304,18 +10148,18 @@ program.name(BIN_NAME).description("Fling a folder of static files at Fling and
   `server for this command: a URL, or the host of one you signed in to (default: $${ENV.url}, else the current one)`
 ).option("--json", "print JSON instead of human output", false).showHelpAfterError().configureHelp({
   sortSubcommands: false,
-  styleTitle: (title) => chalk14.bold(brand.primary(title)),
-  styleCommandText: (text2) => chalk14.bold(text2),
+  styleTitle: (title) => chalk15.bold(brand.primary(title)),
+  styleCommandText: (text2) => chalk15.bold(text2),
   styleSubcommandText: (text2) => brand.accent(text2),
   styleOptionText: (text2) => brand.accent(text2),
-  styleArgumentText: (text2) => chalk14.dim(text2)
+  styleArgumentText: (text2) => chalk15.dim(text2)
 }).addHelpText(
   "before",
   () => process.stdout.isTTY ? logo({ columns: process.stdout.columns }) : ""
 ).addHelpText(
   "after",
   () => `
-${chalk14.bold(brand.primary("Examples:"))}
+${chalk15.bold(brand.primary("Examples:"))}
   $ ${BIN_NAME} login https://fling.example.com  sign in to your Fling (once; there is no default)
   $ ${BIN_NAME} setup                      sign in and add Fling to Claude Code / Claude Desktop
   $ ${BIN_NAME} use                        list the Flings you signed in to; \`use <url>\` switches
@@ -9326,7 +10170,7 @@ ${chalk14.bold(brand.primary("Examples:"))}
   $ ${BIN_NAME} site.zip                   a zip of a site
   $ ${BIN_NAME} share my-app               public link for people who can't sign in
 
-${chalk14.dim(`Exit codes: 0 ok \xB7 1 error \xB7 2 not logged in \xB7 3 forbidden
+${chalk15.dim(`Exit codes: 0 ok \xB7 1 error \xB7 2 not logged in \xB7 3 forbidden
 Env:        ${ENV.apiKey} \xB7 ${ENV.url} \xB7 ${ENV.configDir} \xB7 ${ENV.debug}`)}`
 );
 function action(handler) {
@@ -9341,6 +10185,7 @@ function action(handler) {
       report(error, ctx);
       process.exitCode = exitCodeFor(error);
     }
+    if (ctx) await noticeAfterCommand(ctx, globals.server);
   };
 }
 function report(error, ctx) {
@@ -9407,6 +10252,9 @@ program.command("setup [url]").helpGroup("Setup:").description(
     (ctx, url, opts) => runSetup(ctx, { ...opts, url })
   )
 );
+program.command("doctor").helpGroup("Setup:").description(
+  "check this machine: the CLI, its config, each Fling, Claude Code and Claude Desktop (changes nothing)"
+).action(action((ctx) => runDoctor(ctx)));
 program.command("login [url]").helpGroup("Setup:").description(
   "sign in through the browser to the Fling at url and store an API key; it becomes the current server (default: the current one)"
 ).action(