@nearform/fling 0.4.0 → 0.5.0

package/dist/cli.js

@@ -1088,7 +1088,7 @@ function exitCodeFor(error) {
 // package.json
 var package_default = {
   name: "@nearform/fling",
-  version: "0.4.0",
+  version: "0.5.0",
   license: "MIT",
   description: "Fling a folder of static files at a Fling server and get a link back. CLI + MCP server.",
   type: "module",
@@ -1308,7 +1308,9 @@ var ENV = {
   configDir: "FLING_CONFIG_DIR",
   debug: "FLING_DEBUG",
   /** Where to look for files given by name (the .mcpb extension sets it from its settings). */
-  downloadsDir: "FLING_DOWNLOADS_DIR"
+  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"
 };
 var serverEntrySchema = z9.object({
   /** What the server said about itself at login. A copy this CLI can't read is just refetched. */
@@ -1327,6 +1329,9 @@ function fromEnv(value) {
   const v = value?.trim();
   return v && !v.startsWith("${") ? v : void 0;
 }
+function serverToAdd(env = process.env) {
+  return fromEnv(env[ENV.addServer]);
+}
 function resolveConfigDir(env = process.env) {
   return env[ENV.configDir] ?? join(env.HOME ?? homedir(), CONFIG_DIR_NAME);
 }
@@ -3841,11 +3846,132 @@ async function findFiles(opts, find = {}) {
   return { files, searched: roots, complete };
 }
 
+// src/mcp-servers.ts
+function serverLabel(url) {
+  const u = new URL(url);
+  return `${u.host}${u.pathname}`.replace(/\/+$/, "");
+}
+function describeServer(s) {
+  const facts = [
+    s.instance?.name,
+    s.signedIn ? s.email ? `signed in as ${s.email}` : "signed in" : "signed out",
+    s.current ? "current: the user's usual one" : void 0
+  ].filter(Boolean);
+  return `${serverLabel(s.url)} (${facts.join("; ")})`;
+}
+function knownServersOf(config) {
+  return Object.entries(config.servers).map(([url, entry]) => ({
+    url,
+    instance: entry.instance,
+    current: url === config.current,
+    signedIn: Boolean(entry.apiKey),
+    ...entry.apiKey && entry.user?.email ? { email: entry.user.email } : {}
+  }));
+}
+var listing = (servers) => servers.map((s) => `- ${describeServer(s)}`).join("\n");
+var ServerNeededError = class extends CliError {
+  servers;
+  constructor(servers, tool2) {
+    super(
+      `Not run: several Flings are set up on this computer, so ${tool2} needs \`server\`.
+${listing(servers)}
+Unless the conversation already says which Fling to use, ask the user (suggest their usual one, marked current). Then call ${tool2} again with \`server\` (e.g. "${serverLabel(servers[0]?.url ?? "https://fling.example.com")}"), and pass the same \`server\` on every call for the rest of the conversation.`
+    );
+    this.name = "ServerNeededError";
+    this.servers = servers;
+  }
+};
+function rememberedServer(config, input) {
+  const servers = knownServersOf(config);
+  const known = servers.length ? `The Flings set up on this computer:
+${listing(servers)}` : "No Fling is set up on this computer yet.";
+  let match;
+  try {
+    match = matchServer(Object.keys(config.servers), input, { loose: true });
+  } catch (error) {
+    throw new CliError(error.message, { hint: known });
+  }
+  if (!match.remembered)
+    throw new CliError(`"${input}" is not a Fling set up on this computer`, {
+      hint: `${known}
+To add one, call fling_login with its address as \`server\`.`
+    });
+  return match.url;
+}
+var isPinned = (config) => config.serverUrlSource === "flag" || config.serverUrlSource === "env";
+async function within(promise, ms, fallback) {
+  let timer;
+  const late = new Promise((r) => {
+    timer = setTimeout(() => r(fallback), ms);
+  });
+  try {
+    return await Promise.race([promise.catch(() => fallback), late]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+var START_FETCH_MS = 5e3;
+async function addServerOnStart(store, address, fetch2) {
+  if (!address) return;
+  let url;
+  try {
+    url = normalizeServerUrl(address);
+  } catch {
+    return;
+  }
+  if (url in (await store.load()).servers) return;
+  const instance = await within(fetchInstance(url, fetch2), START_FETCH_MS, null);
+  await store.putServer(url, instance ? { instance } : {});
+}
+async function knownServers(store, fetch2, pin) {
+  const resolved = await store.resolve({ serverUrl: pin });
+  const config = await store.load();
+  const all = knownServersOf(config);
+  const servers = isPinned(resolved) ? resolved.serverUrl ? [
+    all.find((s) => s.url === resolved.serverUrl) ?? {
+      url: resolved.serverUrl,
+      current: false,
+      signedIn: Boolean(resolved.apiKey)
+    }
+  ] : [] : all;
+  return Promise.all(
+    servers.map(async (s) => {
+      if (s.instance) return s;
+      const instance = await within(fetchInstance(s.url, fetch2), START_FETCH_MS, null);
+      if (instance && s.url in config.servers)
+        await store.putServer(s.url, { instance }, { makeCurrent: false }).catch(() => {
+        });
+      return { ...s, instance };
+    })
+  );
+}
+function serverArgDescription(servers) {
+  const [only] = servers;
+  if (servers.length > 1)
+    return `Which Fling: ${servers.map((s) => serverLabel(s.url)).join(", ")} (an address, host or unique part of it). Required while several Flings are set up: the one settled on for this conversation, on every call`;
+  return `Which Fling, by address or host (any set up on this computer; see fling_servers). Omit it to use ${only ? serverLabel(only.url) : "the one this computer is signed in to"}`;
+}
+function serverToolNote(servers) {
+  if (servers.length < 2) return "";
+  return ` Pass \`server\`: several Flings are set up (${servers.map((s) => serverLabel(s.url)).join(", ")}), and every call names the one settled on for this conversation.`;
+}
+function serversInstructions(servers) {
+  if (servers.length < 2) return void 0;
+  const usual = servers.find((s) => s.current);
+  return [
+    `Several Flings are set up on this computer:
+${listing(servers)}`,
+    `Settle which one this conversation uses before anything else: from the user's words ("on ${serverLabel(servers[0]?.url ?? "")}", "on the ${servers[0]?.instance?.name ?? "other"} one") or, if they don't say, by asking them${usual ? ` (suggest ${serverLabel(usual.url)}, their usual one)` : ""}. Say which Fling you are using, and pass it as \`server\` on every call for the rest of the conversation; switch only when the user asks. Calls without \`server\` do not run while several Flings are set up. Each Fling has its own sites, sign-in and sites domain: give the user the links that come back, which name the Fling.`,
+    "This list was read when this server started and may have changed: call fling_servers to see the Flings set up now. To sign in to a Fling, or add one, call fling_login with its address as `server`."
+  ].join("\n\n");
+}
+
 // src/mcp.ts
 var LOGIN_HINT = `Not logged in to Fling. Call fling_login (it opens the browser to sign in), or ask the user to run \`${NPX_COMMAND} login\` in a terminal (in Claude Code: \`! ${NPX_COMMAND} login\`), then try again.`;
-var NO_SERVER_HINT = `No Fling server is set up on this computer. Ask the user for their Fling's address and to run \`${NPX_COMMAND} login <url>\` in a terminal (in Claude Code: \`! ${NPX_COMMAND} login <url>\`), then try again.`;
+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.`,
+  ...[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.',
   "Confirm the site name with the user before publishing (fling_check_name shows whether it is free and, for a path, the generated name). Names are global, first come first served; when one is taken, offer the suggestions.",
@@ -3855,20 +3981,26 @@ var mcpLocalInstructions = (w, opts = {}) => [
   `Sites are private (only ${w.privateAudience}) by default; only make one public if asked. Use fling_share for a link people who cannot sign in can open. ${opts.comments ? "Always give the user the links that come back: the review link first, as the one to share for feedback, then the site URL." : "Always give the user the URL that comes back."}`,
   ...opts.comments ? [COMMENTS_NOTE(w)] : []
 ].join("\n\n");
-var toolDef = (def) => ({
-  title: def.title,
-  description: def.description,
-  inputSchema: def.inputSchema,
-  annotations: def.annotations
-});
+var onFling = (url, instance) => `
+Fling: ${serverLabel(url)}${instance ? ` (${instance.name})` : ""}`;
 function createMcpServer(deps = {}) {
   const store = deps.store ?? createConfigStore();
   const fetchImpl = deps.fetch ?? ((input, init) => fetch(input, init));
   const cwd = deps.cwd ?? process.cwd();
   const locate = deps.locate ?? { ...systemLocateOptions(), cwd };
   const waitReady = deps.waitReady ?? createReadyWaiter();
-  const wording = mcpWording(deps.instance);
+  const servers = deps.servers ?? [];
+  const several = servers.length > 1;
+  const wording = mcpWording(several ? null : servers[0]?.instance);
   const mcpTools2 = mcpToolsFor(wording);
+  const serverArg = z11.string().min(1).max(500).optional().describe(serverArgDescription(servers));
+  const note = serverToolNote(servers);
+  const serverTool = (def, description = def.description) => ({
+    title: def.title,
+    description: `${description}${note}`,
+    inputSchema: { ...def.inputSchema, server: serverArg },
+    annotations: def.annotations
+  });
   async function edgeReady(url, paths) {
     const r = await waitReady(url, paths).catch(() => ({ ready: false, waitedMs: 0 }));
     return {
@@ -3877,27 +4009,44 @@ function createMcpServer(deps = {}) {
 Not reachable yet at ${url}: ${NOT_READY_NOTE}.`
     };
   }
-  async function client() {
-    const config = await store.resolve({ serverUrl: deps.server });
+  async function choose(server2, tool2) {
+    if (server2 !== void 0)
+      return store.resolve({ serverUrl: rememberedServer(await store.load(), server2) });
+    const resolved = await store.resolve({ serverUrl: deps.server });
+    if (isPinned(resolved)) return resolved;
+    const config = await store.load();
+    const known = knownServersOf(config);
+    if (known.length > 1) throw new ServerNeededError(known, tool2);
+    const only = known[0];
+    return !resolved.serverUrl && only ? store.resolve({ serverUrl: only.url }) : resolved;
+  }
+  async function target(server2, tool2) {
+    const config = await choose(server2, tool2);
     if (!config.serverUrl) throw new NoServerError("fling");
     if (!config.apiKey) throw new CliError("Not logged in", { exitCode: EXIT_NOT_LOGGED_IN });
-    return createApiClient({ serverUrl: config.serverUrl, apiKey: config.apiKey, fetch: fetchImpl });
-  }
-  async function sitesBase() {
-    const config = await store.resolve({ serverUrl: deps.server });
-    return sitesBaseOf(await loadInstance(store, config, fetchImpl));
+    const url = config.serverUrl;
+    let instance;
+    return {
+      client: createApiClient({ serverUrl: url, apiKey: config.apiKey, fetch: fetchImpl }),
+      url,
+      config,
+      instance: () => {
+        instance ??= loadInstance(store, config, fetchImpl);
+        return instance;
+      }
+    };
   }
-  async function run(op) {
+  async function run(tool2, server2, op) {
     try {
-      const { summary, data } = await op(await client());
-      return { content: [{ type: "text", text: `${summary}
+      const { summary, data } = await op(await target(server2, tool2));
+      return textResult(`${summary}
 
-${JSON.stringify(data, null, 2)}` }] };
+${JSON.stringify(data, null, 2)}`);
     } catch (error) {
-      return { isError: true, content: [{ type: "text", text: describeError(error) }] };
+      return failure(error);
     }
   }
-  async function deployFolder(c, dir, opts) {
+  async function deployFolder(t2, dir, opts) {
     let local = await buildManifest(dir);
     local.skipped.dotfiles.unshift(...opts.skippedDotfiles ?? []);
     const skippedNote = describeSkipped(local.skipped).map((l) => `
@@ -3924,14 +4073,14 @@ ${l}.`).join("");
       }
     }
     const result = await deploy(
-      { client: c, fetch: fetchImpl },
+      { client: t2.client, fetch: fetchImpl },
       { dir, name: opts.name, manifest: local, spa: opts.spa, public: opts.public }
     ).catch((error) => {
       if (!(error instanceof NameTakenError)) throw error;
       const how = opts.nameGiven ? "" : ` (generated from ${opts.nameFrom ?? "the folder"})`;
       const pick = error.suggestions.length ? ` Free alternatives: ${error.suggestions.join(", ")}.` : "";
       throw new CliError(
-        `Not deployed: the site name "${error.siteName}"${how} is taken by someone else.${pick} Ask the user which name to use (one of these or their own), then call ${opts.retryWith} again with \`name\`.`
+        `Not deployed: the site name "${error.siteName}"${how} is taken by someone else on ${serverLabel(t2.url)}.${pick} Ask the user which name to use (one of these or their own), then call ${opts.retryWith} again with \`name\`.`
       );
     });
     const what = result.status === "unchanged" ? "Unchanged \u2014 already live" : result.status === "repointed" ? `Restored version ${result.versionId}` : `Deployed ${result.fileCount} files (uploaded ${result.uploaded})`;
@@ -3942,19 +4091,20 @@ Warnings:
       result.url,
       local.files.map((f) => f.path)
     );
-    const instance = deps.instance;
+    const instance = await t2.instance();
     const review = instance && commentsEnabled(instance) ? reviewUrl(instance.appOrigin, result.name) : void 0;
-    const listing = generatedIndex ? " \u2014 with a generated index.html listing the HTML pages" : "";
-    const head = review ? `${what}${listing}.
+    const listing2 = generatedIndex ? " \u2014 with a generated index.html listing the HTML pages" : "";
+    const head = review ? `${what}${listing2}.
 ${shareForFeedback(review, instance?.name ?? "Fling")}
-Site: ${result.url} (${result.site.visibility})` : `${what}: ${result.url} (${result.site.visibility})${listing}`;
+Site: ${result.url} (${result.site.visibility})` : `${what}: ${result.url} (${result.site.visibility})${listing2}`;
     return {
       kind: "deployed",
-      summary: `${head}${warnings}${skippedNote}${edge.note}
+      summary: `${head}${warnings}${skippedNote}${edge.note}${onFling(t2.url, instance)}
 To check exactly which files the site has, call fling_files with name "${result.name}".`,
       data: {
         status: result.status,
         ready: edge.ready,
+        server: t2.url,
         name: result.name,
         nameGenerated: !opts.nameGiven,
         versionId: result.versionId,
@@ -3970,7 +4120,8 @@ To check exactly which files the site has, call fling_files with name "${result.
     { name: "fling", version: VERSION },
     {
       instructions: mcpLocalInstructions(wording, {
-        comments: commentsEnabled(deps.instance)
+        comments: servers.some((s) => commentsEnabled(s.instance)),
+        servers
       })
     }
   );
@@ -3979,7 +4130,7 @@ To check exactly which files the site has, call fling_files with name "${result.
     "fling_deploy",
     {
       title: "Deploy a file or folder from this computer",
-      description: `Fling something that is on the user's computer and return its stable URL (${wording.sitesPattern}): a folder of static files (e.g. a build output like dist/), a single .html file (served as the site's index.html), a .zip of a site (extracted; a single top-level folder is unwrapped), or any other single file (.pdf, .svg, .png\u2026, served next to a generated page that shows it). \`path\` can be absolute, relative to the working directory, or just a file name ("Pitch Deck.html"): names are looked up, newest first, in Downloads, Desktop, Documents/Claude and Claude Desktop output folders, and the result says where the file was found. Never pass paths from your own sandbox (/mnt/user-data/\u2026, /sessions/\u2026): for content you created, use fling_publish. Without \`name\`, a name is generated: from the file name for files ("Pitch Deck (1).html" \u2192 pitch-deck), from the project and folder for folders (~/work/rocketpod/docs \u2192 rocketpod-docs). Site names are one global namespace, first come first served \u2014 confirm the name with the user first (fling_check_name with \`path\` shows the generated one). If the name is taken it fails with free suggestions \u2014 ask the user to pick one, then retry with \`name\`. If there is no index.html but there are HTML pages, it does not deploy: ask the user whether to generate an index page listing them (\`listHtml: true\`) or deploy without one (\`listHtml: false\`), then retry. Re-deploying identical content is a no-op. Sites are private (only ${wording.privateAudience}) unless \`public\` is set. ` + NEVER_PUBLISHED,
+      description: `Fling something that is on the user's computer and return its stable URL (${wording.sitesPattern}): a folder of static files (e.g. a build output like dist/), a single .html file (served as the site's index.html), a .zip of a site (extracted; a single top-level folder is unwrapped), or any other single file (.pdf, .svg, .png\u2026, served next to a generated page that shows it). \`path\` can be absolute, relative to the working directory, or just a file name ("Pitch Deck.html"): names are looked up, newest first, in Downloads, Desktop, Documents/Claude and Claude Desktop output folders, and the result says where the file was found. Never pass paths from your own sandbox (/mnt/user-data/\u2026, /sessions/\u2026): for content you created, use fling_publish. Without \`name\`, a name is generated: from the file name for files ("Pitch Deck (1).html" \u2192 pitch-deck), from the project and folder for folders (~/work/rocketpod/docs \u2192 rocketpod-docs). Site names are one global namespace, first come first served \u2014 confirm the name with the user first (fling_check_name with \`path\` shows the generated one). If the name is taken it fails with free suggestions \u2014 ask the user to pick one, then retry with \`name\`. If there is no index.html but there are HTML pages, it does not deploy: ask the user whether to generate an index page listing them (\`listHtml: true\`) or deploy without one (\`listHtml: false\`), then retry. Re-deploying identical content is a no-op. Sites are private (only ${wording.privateAudience}) unless \`public\` is set. ${NEVER_PUBLISHED}${note}`,
       inputSchema: {
         path: z11.string().min(1).describe(
           "File or folder on this computer: absolute, relative to the working directory, or just its name (looked up in Downloads, Desktop and Claude output folders)"
@@ -3989,16 +4140,17 @@ To check exactly which files the site has, call fling_files with name "${result.
         ),
         spa: spa2,
         public: isPublic,
-        listHtml: listHtml2
+        listHtml: listHtml2,
+        server: serverArg
       },
       annotations: { destructiveHint: false, idempotentHint: true, openWorldHint: true }
     },
-    (args) => run(async (c) => {
+    (args) => run("fling_deploy", args.server, async (t2) => {
       const located = await resolveInput(args.path, locate);
       const prepared = await prepareInput(located.path);
       try {
         const name = args.name !== void 0 ? resolveSiteName(prepared.dir, args.name) : prepared.defaultName;
-        const outcome = await deployFolder(c, prepared.dir, {
+        const outcome = await deployFolder(t2, prepared.dir, {
           name,
           nameGiven: args.name !== void 0,
           nameFrom: prepared.kind === "folder" ? "the folder" : "the file name",
@@ -4052,33 +4204,31 @@ ${lines.join("\n")}` : `Nothing found from the last ${args.days ?? 14} days${arg
           searched: searched.map((r) => ({ label: r.label, path: r.path })),
           ...complete ? {} : { truncated: true }
         };
-        return {
-          content: [{ type: "text", text: `${summary}
+        return textResult(`${summary}
 
-${JSON.stringify(data, null, 2)}` }]
-        };
+${JSON.stringify(data, null, 2)}`);
       } catch (error) {
-        return { isError: true, content: [{ type: "text", text: describeError(error) }] };
+        return failure(error);
       }
     }
   );
   const publishDef = mcpTools2.publish;
   server.registerTool(
     publishDef.name,
-    {
-      ...toolDef(publishDef),
+    serverTool(
+      publishDef,
       // This server has no chunked upload tools; big sites go through fling_deploy instead.
-      description: publishDef.description.replace(
+      publishDef.description.replace(
         /\(whole site, up to [^;]*; bigger sites: fling_upload_begin \/ fling_upload_file \/ fling_upload_finish\)/,
         "(whole site; for a big site that is already on this computer, use fling_deploy with its folder)"
       )
-    },
-    (args) => run(async (c) => {
+    ),
+    (args) => run(publishDef.name, args.server, async (t2) => {
       const name = resolveSiteName(".", args.name);
       const tmp = await mkdtemp3(join6(tmpdir3(), "fling-publish-"));
       try {
         const { skippedDotfiles } = await writeInlineFiles(tmp, args.files);
-        const outcome = await deployFolder(c, tmp, {
+        return await deployFolder(t2, tmp, {
           skippedDotfiles,
           name,
           nameGiven: true,
@@ -4087,7 +4237,6 @@ ${JSON.stringify(data, null, 2)}` }]
           listHtml: args.listHtml,
           retryWith: "fling_publish"
         });
-        return outcome;
       } finally {
         await rm2(tmp, { recursive: true, force: true });
       }
@@ -4096,14 +4245,15 @@ ${JSON.stringify(data, null, 2)}` }]
   server.registerTool(
     "fling_check_name",
     {
-      ...toolDef(mcpTools2.checkName),
-      description: `${mcpTools2.checkName.description} Pass \`path\` instead of \`name\` to see the name fling_deploy would generate for a file or folder on this computer (same lookup as fling_deploy), so you can confirm it with the user.`,
+      ...serverTool(mcpTools2.checkName),
+      description: `${mcpTools2.checkName.description} Pass \`path\` instead of \`name\` to see the name fling_deploy would generate for a file or folder on this computer (same lookup as fling_deploy), so you can confirm it with the user.${note}`,
       inputSchema: {
         name: z11.string().min(1).max(200).optional().describe("Site name to check"),
-        path: z11.string().optional().describe("File or folder whose generated default name to check (path or file name)")
+        path: z11.string().optional().describe("File or folder whose generated default name to check (path or file name)"),
+        server: serverArg
       }
     },
-    (args) => run(async (c) => {
+    (args) => run("fling_check_name", args.server, async (t2) => {
       if (args.name === void 0 && args.path === void 0)
         throw new CliError("Pass `name` or `path`");
       let name = args.name;
@@ -4112,8 +4262,8 @@ ${JSON.stringify(data, null, 2)}` }]
         source = await resolveInput(args.path, locate);
         name = defaultNameFor(source.path, source.isDirectory);
       }
-      const check2 = await checkName(c, name);
-      const base = check2.status === "invalid" ? null : await sitesBase();
+      const check2 = await checkName(t2.client, name);
+      const base = check2.status === "invalid" ? null : sitesBaseOf(await t2.instance());
       const url = base ? siteUrlFor(name, base) : null;
       const suggestions = check2.suggestions.length ? ` Suggestions: ${check2.suggestions.join(", ")}.` : "";
       const summary = {
@@ -4127,59 +4277,77 @@ ${JSON.stringify(data, null, 2)}` }]
         data: {
           ...check2,
           url,
+          server: t2.url,
           ...source ? { generated: true, source: { path: source.path, foundIn: source.foundIn } } : {}
         }
       };
     })
   );
-  let pendingLogin;
+  const pendingLogins = /* @__PURE__ */ new Map();
   server.registerTool(
     "fling_login",
     {
       title: "Sign in to Fling",
-      description: `Sign the user in to ${wording.name}: opens their browser to sign in with ${wording.signIn} and stores the key on this computer (shared with the fling CLI). Waits up to ~30 seconds; if sign-in is not finished by then, it keeps waiting in the background for up to 5 minutes \u2014 tell the user to finish signing in in the browser, then retry what you were doing. Call it when another tool says the user is not logged in.`,
-      inputSchema: {},
+      description: `Sign the user in to ${several ? "a Fling" : wording.name}: opens their browser to sign in with ${wording.signIn} and stores the key on this computer (shared with the fling CLI). Waits up to ~30 seconds; if sign-in is not finished by then, it keeps waiting in the background for up to 5 minutes \u2014 tell the user to finish signing in in the browser, then retry what you were doing. Call it when another tool says the user is not logged in. Pass \`server\` (its address) to sign in to another Fling, including one not set up on this computer yet: it is remembered, and becomes the current one only when none is.` + note,
+      inputSchema: {
+        server: z11.string().min(1).max(500).optional().describe(
+          `The Fling to sign in to: its address (e.g. "https://fling.example.com"), or the host of one set up on this computer. ${several ? `Required while several Flings are set up (${servers.map((s) => serverLabel(s.url)).join(", ")})` : `Omit it to use ${servers[0] ? serverLabel(servers[0].url) : "the one this computer knows"}`}`
+        )
+      },
       annotations: { readOnlyHint: false, openWorldHint: true }
     },
-    async () => {
+    async (args) => {
       try {
-        const config = await store.resolve({ serverUrl: deps.server });
-        const serverUrl = config.serverUrl;
+        let serverUrl;
+        if (args.server !== void 0) {
+          const config2 = await store.load();
+          try {
+            serverUrl = matchServer(Object.keys(config2.servers), args.server, { loose: true }).url;
+          } catch (error) {
+            const known = knownServersOf(config2).map((s) => `- ${describeServer(s)}`);
+            throw new CliError(error.message, {
+              hint: known.length ? `The Flings set up on this computer:
+${known.join("\n")}` : ""
+            });
+          }
+        } else {
+          serverUrl = (await choose(void 0, "fling_login")).serverUrl;
+        }
         if (!serverUrl) throw new NoServerError("fling");
-        if (config.apiKey && !pendingLogin) {
+        const config = await store.resolve({ serverUrl });
+        let login = pendingLogins.get(serverUrl);
+        if (config.apiKey && !login) {
           const me = await whoami(
-            createApiClient({
-              serverUrl,
-              apiKey: config.apiKey,
-              fetch: fetchImpl
-            })
+            createApiClient({ serverUrl, apiKey: config.apiKey, fetch: fetchImpl })
           ).catch(() => null);
-          if (me) return textResult(`Already signed in to ${config.serverUrl} as ${me.email}.`);
+          if (me) return textResult(`Already signed in to ${serverUrl} as ${me.email}.`);
         }
-        if (!pendingLogin) {
-          const login = {
+        if (!login) {
+          const started = {
             done: Promise.resolve()
           };
-          login.done = loginFlow({
+          started.done = loginFlow({
             serverUrl,
             store,
             log: silentLogger,
             open: deps.open ?? (async (url) => (await import("open")).default(url)),
             fetch: fetchImpl,
             timeoutMs: deps.loginTimeoutMs,
-            // Signing in to the extension's server leaves the CLI's current server as it is.
+            // Signing in to another Fling leaves the CLI's current server as it is.
             makeCurrent: !config.current || config.current === serverUrl,
             onAuthUrl: (url) => {
-              login.url = url;
+              started.url = url;
             }
           });
-          login.done.catch(() => {
+          const key = serverUrl;
+          started.done.catch(() => {
           }).finally(() => {
-            if (pendingLogin === login) pendingLogin = void 0;
+            if (pendingLogins.get(key) === started) pendingLogins.delete(key);
           });
-          pendingLogin = login;
+          pendingLogins.set(serverUrl, started);
+          login = started;
         }
-        const current = pendingLogin;
+        const current = login;
         const waited = await Promise.race([
           current.done.then(
             (r) => ({ ok: true, r }),
@@ -4192,34 +4360,82 @@ ${JSON.stringify(data, null, 2)}` }]
             `Finish signing in in your browser, then try again. (The sign-in page is open; if it did not open, visit: ${current.url ?? "the Fling site"} \u2014 this stays valid for 5 minutes.)`
           );
         if (!waited.ok) throw waited.e;
-        return textResult(`Signed in as ${waited.r.user.email} (${waited.r.serverUrl}).`);
+        return textResult(
+          `Signed in as ${waited.r.user.email} (${waited.r.serverUrl}, ${waited.r.instance.name}).`
+        );
+      } catch (error) {
+        return failure(error);
+      }
+    }
+  );
+  server.registerTool(
+    "fling_servers",
+    {
+      title: "List the Flings on this computer",
+      description: `List the Flings set up on this computer, read now: each one's address, name, who is signed in (or "signed out") and which is current, the user's usual one. Call it when unsure which Fling the user means or which exist; the list may have changed since this conversation started. Pass \`use\` to make one the current Fling, the same as running \`${NPX_COMMAND} use <server>\`: it changes the default of the fling CLI too, so only do it when the user asks. It does not replace passing \`server\` to the other tools while several Flings are set up.`,
+      inputSchema: {
+        use: z11.string().min(1).max(500).optional().describe(
+          "Make this Fling current (address, host or unique part of it), like `fling use`"
+        )
+      },
+      annotations: { readOnlyHint: false, idempotentHint: true, openWorldHint: false }
+    },
+    async (args) => {
+      try {
+        let switched = "";
+        if (args.use !== void 0) {
+          const url = rememberedServer(await store.load(), args.use);
+          await store.setCurrent(url);
+          switched = `Now using ${serverLabel(url)} as the current Fling (as \`fling use\` does).
+`;
+        }
+        const config = await store.load();
+        const known = knownServersOf(config);
+        const pinned = await store.resolve({ serverUrl: deps.server });
+        const summary = known.length ? `${switched}${known.length} Fling(s) set up on this computer:
+${known.map((s) => `- ${describeServer(s)}`).join("\n")}` + (isPinned(pinned) && pinned.serverUrl ? `
+Calls without \`server\` go to ${serverLabel(pinned.serverUrl)} (set by this server's configuration).` : known.length > 1 ? "\nPass `server` on every call: the Fling settled on for this conversation." : "") : NO_SERVER_HINT;
+        const data = {
+          current: config.current ?? null,
+          servers: known.map((s) => ({
+            url: s.url,
+            host: serverLabel(s.url),
+            instance: s.instance?.name ?? null,
+            signedIn: s.signedIn,
+            email: s.email ?? null,
+            current: s.current
+          }))
+        };
+        return textResult(`${summary}
+
+${JSON.stringify(data, null, 2)}`);
       } catch (error) {
-        return { isError: true, content: [{ type: "text", text: describeError(error) }] };
+        return failure(error);
       }
     }
   );
   const t = mcpTools2;
   server.registerTool(
     t.list.name,
-    toolDef(t.list),
-    (args) => run(async (c) => {
-      const sites = await listSites(c, { archived: args.archived });
-      return { summary: `${sites.length} site(s)`, data: { sites } };
+    serverTool(t.list),
+    (args) => run(t.list.name, args.server, async ({ client, url }) => {
+      const sites = await listSites(client, { archived: args.archived });
+      return { summary: `${sites.length} site(s) on ${serverLabel(url)}`, data: { sites } };
     })
   );
   server.registerTool(
     t.info.name,
-    toolDef(t.info),
-    (args) => run(async (c) => {
-      const site = await getSite(c, args.name);
+    serverTool(t.info),
+    (args) => run(t.info.name, args.server, async ({ client }) => {
+      const site = await getSite(client, args.name);
       return { summary: `${site.name}: ${site.url}`, data: site };
     })
   );
   server.registerTool(
     t.files.name,
-    toolDef(t.files),
-    (args) => run(async (c) => {
-      const result = await versionFiles(c, args.name, args.versionId);
+    serverTool(t.files),
+    (args) => run(t.files.name, args.server, async ({ client }) => {
+      const result = await versionFiles(client, args.name, args.versionId);
       return {
         summary: describeVersionFiles(result.name, result, {
           current: result.current,
@@ -4231,15 +4447,15 @@ ${JSON.stringify(data, null, 2)}` }]
   );
   server.registerTool(
     t.share.name,
-    toolDef(t.share),
-    (args) => run(async (c) => {
+    serverTool(t.share),
+    (args) => run(t.share.name, args.server, async ({ client }) => {
       if (args.refresh && args.revoke) throw new CliError("Use either refresh or revoke, not both");
-      const result = await share(c, args.name, args);
+      const result = await share(client, args.name, args);
       if (result.action === "revoked")
         return { summary: `Share link for ${args.name} revoked`, data: result };
       let edge = { ready: true, note: "" };
       if (result.action !== "existing") {
-        const files = await versionFiles(c, args.name).catch(() => null);
+        const files = await versionFiles(client, args.name).catch(() => null);
         edge = await edgeReady(result.shareUrl, files?.files.map((f) => f.path) ?? []);
       }
       return {
@@ -4250,78 +4466,86 @@ ${JSON.stringify(data, null, 2)}` }]
   );
   server.registerTool(
     t.setVisibility.name,
-    toolDef(t.setVisibility),
-    (args) => run(async (c) => {
-      const site = await setVisibility(c, args.name, args.visibility);
+    serverTool(t.setVisibility),
+    (args) => run(t.setVisibility.name, args.server, async ({ client }) => {
+      const site = await setVisibility(client, args.name, args.visibility);
       return { summary: `${site.name} is now ${site.visibility}: ${site.url}`, data: site };
     })
   );
   server.registerTool(
     t.archive.name,
-    toolDef(t.archive),
-    (args) => run(async (c) => {
-      const site = await archiveSite(c, args.name, { unarchive: args.unarchive });
+    serverTool(t.archive),
+    (args) => run(t.archive.name, args.server, async ({ client }) => {
+      const site = await archiveSite(client, args.name, { unarchive: args.unarchive });
       return { summary: `${site.name} ${args.unarchive ? "restored" : "archived"}`, data: site };
     })
   );
   server.registerTool(
     t.delete.name,
-    toolDef(t.delete),
-    (args) => run(async (c) => {
-      const result = await deleteSite(c, args.name);
-      return { summary: `${args.name} deleted`, data: result };
+    serverTool(t.delete),
+    (args) => run(t.delete.name, args.server, async ({ client, url }) => {
+      const result = await deleteSite(client, args.name);
+      return { summary: `${args.name} deleted from ${serverLabel(url)}`, data: result };
     })
   );
   server.registerTool(
     t.rollback.name,
-    toolDef(t.rollback),
-    (args) => run(async (c) => {
-      const site = await rollback(c, args.name, args.versionId);
+    serverTool(t.rollback),
+    (args) => run(t.rollback.name, args.server, async ({ client }) => {
+      const site = await rollback(client, args.name, args.versionId);
       return {
         summary: `${site.name} now serves version ${site.currentVersionId}: ${site.url}`,
         data: site
       };
     })
   );
-  if (deps.instance && commentsEnabled(deps.instance)) {
-    const appOrigin = deps.instance.appOrigin;
-    const review = (name) => reviewUrl(appOrigin, name);
+  if (servers.some((s) => commentsEnabled(s.instance))) {
+    async function reviewOn(target2) {
+      const instance = await target2.instance();
+      if (instance?.capabilities.comments === false)
+        throw new CliError(`${instance.name} (${serverLabel(target2.url)}) has comments turned off`);
+      const appOrigin = instance?.appOrigin ?? target2.url;
+      return {
+        review: (name) => reviewUrl(appOrigin, name),
+        fling: onFling(target2.url, instance)
+      };
+    }
     server.registerTool(
       t.commentsList.name,
-      toolDef(t.commentsList),
-      (args) => run(async (c) => {
-        const list = await listComments(c, args.name, { path: args.path });
+      serverTool(t.commentsList),
+      (args) => run(t.commentsList.name, args.server, async (target2) => {
+        const { review, fling } = await reviewOn(target2);
+        const list = await listComments(target2.client, args.name, { path: args.path });
         const reviewPage2 = review(list.site.name);
         return {
-          summary: describeComments(list, {
-            includeResolved: args.includeResolved,
-            reviewUrl: reviewPage2
-          }),
+          summary: `${describeComments(list, { includeResolved: args.includeResolved, reviewUrl: reviewPage2 })}${fling}`,
           data: { ...list, reviewUrl: reviewPage2 }
         };
       })
     );
     server.registerTool(
       t.commentAdd.name,
-      toolDef(t.commentAdd),
-      (args) => run(async (c) => {
-        const comment = await addComment(c, args.name, {
+      serverTool(t.commentAdd),
+      (args) => run(t.commentAdd.name, args.server, async (target2) => {
+        const { review, fling } = await reviewOn(target2);
+        const comment = await addComment(target2.client, args.name, {
           body: args.body,
           path: args.path,
           parentId: args.replyTo
         });
         const what = comment.parentId ? `Replied to thread ${comment.parentId}` : "Comment added";
         return {
-          summary: `${what} on ${args.name} (${comment.path}, id ${comment.id}). Review page: ${review(args.name)}`,
+          summary: `${what} on ${args.name} (${comment.path}, id ${comment.id}). Review page: ${review(args.name)}${fling}`,
           data: comment
         };
       })
     );
     server.registerTool(
       t.commentResolve.name,
-      toolDef(t.commentResolve),
-      (args) => run(async (c) => {
-        const comment = await resolveComment(c, args.name, args.id, !args.reopen);
+      serverTool(t.commentResolve),
+      (args) => run(t.commentResolve.name, args.server, async (target2) => {
+        await reviewOn(target2);
+        const comment = await resolveComment(target2.client, args.name, args.id, !args.reopen);
         return {
           summary: `Thread ${comment.id} on ${args.name} ${args.reopen ? "reopened" : "resolved"}`,
           data: comment
@@ -4330,22 +4554,24 @@ ${JSON.stringify(data, null, 2)}` }]
     );
     server.registerTool(
       t.commentDelete.name,
-      toolDef(t.commentDelete),
-      (args) => run(async (c) => {
-        const result = await deleteComment(c, args.name, args.id);
+      serverTool(t.commentDelete),
+      (args) => run(t.commentDelete.name, args.server, async (target2) => {
+        await reviewOn(target2);
+        const result = await deleteComment(target2.client, args.name, args.id);
         return { summary: `Comment ${args.id} on ${args.name} deleted`, data: result };
       })
     );
   }
   server.registerTool(
     t.whoami.name,
-    toolDef(t.whoami),
-    () => run(async (c) => {
-      const me = await whoami(c);
-      const base = await sitesBase();
+    serverTool(t.whoami),
+    (args) => run(t.whoami.name, args.server, async (target2) => {
+      const me = await whoami(target2.client);
+      const instance = await target2.instance();
+      const base = sitesBaseOf(instance);
       return {
-        summary: `Signed in as ${me.email} (sites are served at ${sitesPattern(base)})`,
-        data: me
+        summary: `Signed in to ${serverLabel(target2.url)}${instance ? ` (${instance.name})` : ""} as ${me.email} (sites are served at ${sitesPattern(base)})`,
+        data: { ...me, server: target2.url }
       };
     })
   );
@@ -4382,6 +4608,25 @@ async function writeInlineFiles(dir, files) {
   if (secretFiles.length > 0) throw new SecretFilesError(secretFiles);
   return { skippedDotfiles };
 }
+function failure(error) {
+  if (error instanceof ServerNeededError) {
+    const data = {
+      status: "needs_server",
+      servers: error.servers.map((s) => ({
+        url: s.url,
+        host: serverLabel(s.url),
+        instance: s.instance?.name ?? null,
+        signedIn: s.signedIn,
+        email: s.email ?? null,
+        current: s.current
+      }))
+    };
+    return textResult(`${error.message}
+
+${JSON.stringify(data, null, 2)}`);
+  }
+  return { isError: true, content: [{ type: "text", text: describeError(error) }] };
+}
 function describeError(error) {
   if (error instanceof NoServerError) return NO_SERVER_HINT;
   if (error instanceof CliError && error.exitCode === EXIT_NOT_LOGGED_IN) return LOGIN_HINT;
@@ -4393,8 +4638,11 @@ ${error.hint}` : error.message;
 }
 async function runMcpServer(deps = {}) {
   const store = deps.store ?? createConfigStore();
-  const instance = deps.instance ?? await store.resolve({ serverUrl: deps.server }).then((config) => loadInstance(store, config, deps.fetch ?? ((i, init) => fetch(i, init)))).catch(() => null);
-  const server = createMcpServer({ ...deps, store, instance });
+  const fetchImpl = deps.fetch ?? ((i, init) => fetch(i, init));
+  await addServerOnStart(store, serverToAdd(), fetchImpl).catch(() => {
+  });
+  const servers = deps.servers ?? await knownServers(store, fetchImpl, deps.server).catch(() => []);
+  const server = createMcpServer({ ...deps, store, servers });
   await server.connect(new StdioServerTransport());
 }