@nearform/fling 0.3.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.3.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,18 +1308,19 @@ 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 cliConfigSchema = z9.object({
-  serverUrl: z9.string().url().optional(),
-  /** What `serverUrl` said about itself at login. A copy a newer CLI can't read is just refetched. */
+var serverEntrySchema = z9.object({
+  /** What the server said about itself at login. A copy this CLI can't read is just refetched. */
   instance: InstanceMetadataSchema.optional().catch(void 0),
-  apiKey: z9.string().min(1).optional(),
+  apiKey: z9.string().min(1).optional().catch(void 0),
   user: z9.object({
     email: z9.string().optional(),
     name: z9.string().optional(),
     userSlug: z9.string().optional()
-  }).optional()
+  }).optional().catch(void 0)
 });
 function systemLocateOptions(env = process.env) {
   return { cwd: process.cwd(), home: homedir(), platform: process.platform, env };
@@ -1328,9 +1329,43 @@ 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);
 }
+function safeNormalize(input) {
+  if (typeof input !== "string") return void 0;
+  try {
+    return normalizeServerUrl(input);
+  } catch {
+    return void 0;
+  }
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseConfig(json) {
+  if (!isObject(json)) throw new Error("expected a JSON object");
+  const servers = {};
+  let current;
+  if ("servers" in json) {
+    if (isObject(json.servers)) {
+      for (const [key, value] of Object.entries(json.servers)) {
+        const url = safeNormalize(key);
+        const entry = isObject(value) ? serverEntrySchema.safeParse(value) : void 0;
+        if (url && entry?.success) servers[url] = { ...servers[url], ...entry.data };
+      }
+    }
+    current = safeNormalize(json.current);
+  } else {
+    current = safeNormalize(json.serverUrl);
+    if (current) servers[current] = serverEntrySchema.parse(json);
+  }
+  if (current && !servers[current]) servers[current] = {};
+  return current ? { current, servers } : { servers };
+}
 function createConfigStore(options = {}) {
   const env = options.env ?? process.env;
   const dir = options.dir ?? resolveConfigDir(env);
@@ -1340,7 +1375,7 @@ function createConfigStore(options = {}) {
     try {
       raw = await readFile(file, "utf8");
     } catch (error) {
-      if (error.code === "ENOENT") return {};
+      if (error.code === "ENOENT") return { servers: {} };
       throw error;
     }
     let json;
@@ -1349,57 +1384,115 @@ function createConfigStore(options = {}) {
     } catch {
       throw new Error(`Config file ${file} is not valid JSON`);
     }
-    const parsed = cliConfigSchema.safeParse(json);
-    if (!parsed.success) {
-      throw new Error(`Config file ${file} is invalid: ${parsed.error.issues[0]?.message}`);
+    try {
+      return parseConfig(json);
+    } catch (error) {
+      throw new Error(`Config file ${file} is invalid: ${error.message}`);
     }
-    return parsed.data;
   }
   async function save(config) {
     await mkdir(dir, { recursive: true, mode: 448 });
     await chmod(dir, 448).catch(() => {
     });
-    await writeFile(file, `${JSON.stringify(config, null, 2)}
+    const body = { current: config.current, servers: config.servers };
+    await writeFile(file, `${JSON.stringify(body, null, 2)}
 `, { mode: 384 });
     await chmod(file, 384);
   }
+  async function edit(change) {
+    const config = await load();
+    change(config);
+    await save(config);
+    return config;
+  }
   return {
     dir,
     file,
     load,
     save,
-    async update(patch) {
-      const next = { ...await load(), ...patch };
-      await save(next);
-      return next;
+    putServer(serverUrl, patch, opts = {}) {
+      const url = normalizeServerUrl(serverUrl);
+      return edit((config) => {
+        config.servers[url] = { ...config.servers[url], ...patch };
+        if (opts.makeCurrent ?? !config.current) config.current = url;
+      });
+    },
+    async setCurrent(serverUrl) {
+      const url = normalizeServerUrl(serverUrl);
+      await edit((config) => {
+        config.servers[url] ??= {};
+        config.current = url;
+      });
     },
-    async clearCredentials() {
-      const { serverUrl, instance } = await load();
-      await save({ serverUrl, instance });
+    async clearCredentials(serverUrl) {
+      const url = normalizeServerUrl(serverUrl);
+      await edit((config) => {
+        const entry = config.servers[url];
+        if (entry) config.servers[url] = entry.instance ? { instance: entry.instance } : {};
+      });
+    },
+    async removeServer(serverUrl) {
+      const url = normalizeServerUrl(serverUrl);
+      await edit((config) => {
+        delete config.servers[url];
+        if (config.current === url) config.current = void 0;
+      });
     },
     async resolve(overrides = {}) {
       const config = await load();
       const envUrl = fromEnv(env[ENV.url]);
       const envKey = fromEnv(env[ENV.apiKey]);
-      const [rawUrl, serverUrlSource] = overrides.serverUrl ? [overrides.serverUrl, "flag"] : envUrl ? [envUrl, "env"] : config.serverUrl ? [config.serverUrl, "config"] : [void 0, "none"];
-      const serverUrl = rawUrl === void 0 ? void 0 : normalizeServerUrl(rawUrl);
-      const [apiKey, apiKeySource] = envKey ? [envKey, "env"] : config.apiKey ? [config.apiKey, "config"] : [void 0, "none"];
-      const stored = config.serverUrl && normalizeServerUrl(config.serverUrl);
+      const [rawUrl, serverUrlSource] = overrides.serverUrl ? [overrides.serverUrl, "flag"] : envUrl ? [envUrl, "env"] : config.current ? [config.current, "config"] : [void 0, "none"];
+      const serverUrl = rawUrl === void 0 ? void 0 : matchServer(Object.keys(config.servers), rawUrl, { loose: true }).url;
+      const entry = serverUrl === void 0 ? void 0 : config.servers[serverUrl];
+      const [apiKey, apiKeySource] = envKey ? [envKey, "env"] : entry?.apiKey ? [entry.apiKey, "config"] : [void 0, "none"];
       return {
         serverUrl,
         serverUrlSource,
-        instance: serverUrl && stored === serverUrl ? config.instance : void 0,
+        current: config.current,
+        remembered: entry !== void 0,
+        instance: entry?.instance,
         apiKey,
         apiKeySource,
-        user: config.user,
+        user: entry?.user,
         debug: Boolean(env[ENV.debug])
       };
     }
   };
 }
+var HAS_SCHEME = /^[a-z][a-z0-9+.-]*:\/\//i;
+function matchServer(remembered, input, options = {}) {
+  const trimmed = input.trim();
+  const normalized = safeNormalize(trimmed);
+  if (normalized && remembered.includes(normalized)) return { url: normalized, remembered: true };
+  if (!HAS_SCHEME.test(trimmed)) {
+    const bare = trimmed.replace(/\/+$/, "").toLowerCase();
+    const parts = remembered.map((url) => {
+      const u = new URL(url);
+      return { url, host: u.host, hostname: u.hostname, address: `${u.host}${u.pathname}` };
+    });
+    const tiers = [
+      parts.filter((p) => p.host === bare || p.address === bare),
+      options.loose && bare ? parts.filter((p) => p.address.startsWith(bare) || p.hostname.endsWith(`.${bare}`)) : []
+    ];
+    for (const found of tiers) {
+      const [only] = found;
+      if (only && found.length === 1) return { url: only.url, remembered: true };
+      if (found.length > 1)
+        throw new CliError(`"${input}" matches more than one server you have signed in to`, {
+          hint: `Use the full address: ${found.map((p) => p.url).join(", ")}`
+        });
+    }
+  }
+  if (!normalized)
+    throw new CliError(`"${input}" is not a server address`, {
+      hint: "Use your Fling's address, e.g. https://fling.example.com."
+    });
+  return { url: normalized, remembered: false };
+}
 function normalizeServerUrl(input) {
   const trimmed = input.trim();
-  const withScheme = /^[a-z][a-z0-9+.-]*:\/\//i.test(trimmed) ? trimmed : `https://${trimmed}`;
+  const withScheme = HAS_SCHEME.test(trimmed) ? trimmed : `https://${trimmed}`;
   const url = new URL(withScheme);
   if (url.protocol !== "https:" && url.protocol !== "http:") {
     throw new Error(`Not an http(s) URL: ${input}`);
@@ -1437,7 +1530,8 @@ async function loadInstance(store, config, fetch2) {
   if (!config.serverUrl) return null;
   try {
     const instance = await fetchInstance(config.serverUrl, fetch2);
-    if (config.serverUrlSource === "config") await store.update({ instance });
+    if (config.remembered)
+      await store.putServer(config.serverUrl, { instance }, { makeCurrent: false });
     return instance;
   } catch {
     return null;
@@ -1469,12 +1563,15 @@ async function loginFlow(options) {
     const { key } = await callback.result;
     const client = createApiClient({ serverUrl, apiKey: key, fetch: options.fetch });
     const user = await client.request("GET", "/api/me", { schema: MeSchema });
-    await store.update({
+    await store.putServer(
       serverUrl,
-      instance,
-      apiKey: key,
-      user: { email: user.email, name: user.name, userSlug: user.userSlug }
-    });
+      {
+        instance,
+        apiKey: key,
+        user: { email: user.email, name: user.name, userSlug: user.userSlug }
+      },
+      { makeCurrent: options.makeCurrent ?? true }
+    );
     const keyPrefix = redactKey(key);
     log.success(`Signed in as ${user.email}`);
     log.hint(`Server: ${serverUrl}`);
@@ -1950,45 +2047,120 @@ function commentsEnabled(instance) {
 }
 
 // src/commands/auth.ts
-function loginServer(ctx, url) {
+async function loginServer(ctx, url) {
   if (url === void 0) return requireServer(ctx);
-  try {
-    return normalizeServerUrl(url);
-  } catch {
-    throw new CliError(`"${url}" is not a server address`, {
-      hint: `Run \`${ctx.binName} login <url>\` with your Fling's address, e.g. https://fling.example.com.`
-    });
-  }
+  const { servers } = await ctx.store.load();
+  return matchServer(Object.keys(servers), url).url;
 }
 async function runLogin(ctx, url) {
   const result = await loginFlow({
-    serverUrl: loginServer(ctx, url),
+    serverUrl: await loginServer(ctx, url),
     store: ctx.store,
     log: ctx.log,
     open: ctx.open,
-    fetch: ctx.fetch
+    fetch: ctx.fetch,
+    makeCurrent: true
   });
   if (ctx.json) ctx.out.data(result, () => "");
 }
-async function runLogout(ctx) {
+async function runUse(ctx, url) {
+  const config = await ctx.store.load();
+  const urls = Object.keys(config.servers);
+  const overridden = ctx.config.serverUrlSource === "env" || ctx.config.serverUrlSource === "flag" ? ctx.config.serverUrl : void 0;
+  const overrideHint = () => {
+    if (overridden)
+      ctx.log.hint(
+        `${ctx.config.serverUrlSource === "env" ? "FLING_URL" : "--server"} is set: commands run with it use ${overridden}.`
+      );
+  };
+  if (url === void 0) {
+    const servers = urls.map((server) => {
+      const entry2 = config.servers[server] ?? {};
+      return {
+        url: server,
+        current: server === config.current,
+        instance: entry2.instance?.name ?? null,
+        email: entry2.apiKey ? entry2.user?.email ?? null : null,
+        signedIn: Boolean(entry2.apiKey)
+      };
+    });
+    if (servers.length === 0 && !ctx.json) {
+      ctx.log.info("No Fling servers yet");
+      ctx.log.hint(`Run \`${ctx.binName} login <url>\` with your Fling's address.`);
+      return;
+    }
+    const width = Math.max(...servers.map((s) => s.url.length));
+    ctx.out.data(
+      { current: config.current ?? null, servers },
+      () => servers.map(
+        (s) => [
+          s.current ? chalk5.bold("*") : " ",
+          s.current ? chalk5.bold(s.url.padEnd(width)) : s.url.padEnd(width),
+          s.instance ?? chalk5.dim("(unknown)"),
+          s.signedIn ? s.email ?? chalk5.dim("(signed in)") : chalk5.dim("(signed out)")
+        ].join("  ")
+      ).join("\n")
+    );
+    if (!ctx.json) {
+      ctx.log.hint(`* = current. Switch with \`${ctx.binName} use <url>\`.`);
+      overrideHint();
+    }
+    return;
+  }
+  const match = matchServer(urls, url, { loose: true });
+  if (!match.remembered)
+    throw new CliError(`Not signed in to ${match.url} on this computer`, {
+      hint: `Run \`${ctx.binName} login ${match.url}\` to add it, or \`${ctx.binName} use\` to list your servers.`
+    });
+  await ctx.store.setCurrent(match.url);
+  const entry = config.servers[match.url] ?? {};
+  const name = entry.instance?.name;
+  const email = entry.apiKey ? entry.user?.email : void 0;
+  ctx.out.data(
+    { current: match.url, instance: name ?? null, email: email ?? null },
+    () => `Now using ${chalk5.bold(match.url)}${name ? chalk5.dim(` (${name})`) : ""}`
+  );
+  if (!ctx.json) {
+    if (entry.apiKey) ctx.log.hint(`Signed in as ${email ?? "an unknown user"}.`);
+    else ctx.log.hint(`Signed out there: run \`${ctx.binName} login\` to sign in.`);
+    overrideHint();
+  }
+}
+async function runLogout(ctx, url) {
   const config = await ctx.store.load();
-  if (!config.apiKey) {
-    ctx.log.info("Not logged in \u2014 nothing to do");
+  const target = url === void 0 ? ctx.config.serverUrl : matchServer(Object.keys(config.servers), url, { loose: true }).url;
+  const entry = target === void 0 ? void 0 : config.servers[target];
+  if (target === void 0 || entry === void 0) {
+    ctx.log.info(`Not logged in${target ? ` to ${target}` : ""} \u2014 nothing to do`);
     return;
   }
-  await ctx.store.clearCredentials();
-  ctx.log.success("Logged out; API key removed from this machine");
-  if (ctx.config.serverUrl)
-    ctx.log.hint(`Revoke it on the server under Connections at ${ctx.config.serverUrl}`);
+  if (target === config.current) {
+    if (!entry.apiKey) {
+      ctx.log.info("Not logged in \u2014 nothing to do");
+      return;
+    }
+    await ctx.store.clearCredentials(target);
+    ctx.log.success("Logged out; API key removed from this machine");
+  } else {
+    await ctx.store.removeServer(target);
+    ctx.log.success(
+      entry.apiKey ? `Logged out of ${target}; API key and server removed from this machine` : `Removed ${target} from this machine`
+    );
+  }
+  if (entry.apiKey) ctx.log.hint(`Revoke it on the server under Connections at ${target}`);
 }
 async function runWhoami(ctx) {
   const client = requireClient(ctx);
   const me = await whoami(client);
   const instance = await loadInstance(ctx.store, ctx.config, ctx.fetch);
+  const { serverUrl, current } = ctx.config;
+  const others = Object.keys((await ctx.store.load()).servers).filter((s) => s !== serverUrl);
   ctx.out.data(
     {
       ...me,
-      serverUrl: ctx.config.serverUrl,
+      serverUrl,
+      serverUrlSource: ctx.config.serverUrlSource,
+      current: current ?? null,
       instance: instance?.name ?? null,
       apiKey: redactKey(ctx.config.apiKey),
       apiKeySource: ctx.config.apiKeySource
@@ -1996,8 +2168,15 @@ async function runWhoami(ctx) {
     () => [
       `${chalk5.bold("User:")}    ${me.name} <${me.email}>`,
       `${chalk5.bold("Sites:")}   ${sitesPattern(sitesBaseOf(instance))} ${chalk5.dim("(names are first come, first served)")}`,
-      `${chalk5.bold("Server:")}  ${ctx.config.serverUrl}${instance ? chalk5.dim(` (${instance.name})`) : ""}`,
-      `${chalk5.bold("API key:")} ${redactKey(ctx.config.apiKey)} ${chalk5.dim(`(from ${ctx.config.apiKeySource})`)}`
+      `${chalk5.bold("Server:")}  ${serverUrl}${instance ? chalk5.dim(` (${instance.name})`) : ""} ${chalk5.dim(
+        serverUrl === current ? "(current)" : `(from ${ctx.config.serverUrlSource === "env" ? "FLING_URL" : "--server"}; current: ${current ?? "none"})`
+      )}`,
+      `${chalk5.bold("API key:")} ${redactKey(ctx.config.apiKey)} ${chalk5.dim(`(from ${ctx.config.apiKeySource})`)}`,
+      ...others.length > 0 ? [
+        chalk5.dim(
+          `${others.length} other server${others.length === 1 ? "" : "s"} on this computer: \`${ctx.binName} use\` lists them`
+        )
+      ] : []
     ].join("\n")
   );
 }
@@ -3119,12 +3298,13 @@ async function runSetup(baseCtx, opts, deps = {}) {
 `);
     intro(chalk8.bold(" fling setup "), { output: process.stderr });
   }
+  const login = await stepLogin(ctx, opts.url);
   const results = {
-    login: await stepLogin(ctx, opts.url),
+    login: login.result,
     claudeCode: "skipped",
     claudeDesktop: "skipped"
   };
-  const after = results.login === "done" ? { ...ctx, config: await ctx.store.resolve() } : ctx;
+  const after = login.serverUrl ? { ...ctx, config: await ctx.store.resolve({ serverUrl: login.serverUrl }) } : ctx;
   results.claudeCode = await stepClaudeCode(after, run, scope, ask, fancy);
   results.claudeDesktop = await stepClaudeDesktop(after, deps, ask, fancy);
   const failed = Object.values(results).includes("failed");
@@ -3137,10 +3317,22 @@ async function runSetup(baseCtx, opts, deps = {}) {
   if (failed) process.exitCode = 1;
 }
 async function stepLogin(ctx, url) {
-  const sameServer = url === void 0 || safeNormalize(url) === ctx.config.serverUrl;
-  if (ctx.config.apiKey && sameServer) {
+  let serverUrl;
+  let target;
+  try {
+    serverUrl = await loginServer(ctx, url);
+    target = { ...ctx, config: await ctx.store.resolve({ serverUrl }) };
+  } catch (error) {
+    ctx.log.error(error instanceof Error ? error.message : String(error));
+    return { result: "failed" };
+  }
+  return { result: await signIn(target, serverUrl), serverUrl };
+}
+async function signIn(ctx, serverUrl) {
+  if (ctx.config.apiKey) {
     try {
       const me = await whoami(requireClient(ctx));
+      if (ctx.config.remembered) await ctx.store.setCurrent(serverUrl);
       ctx.log.success(`Signed in as ${chalk8.bold(me.name)} ${chalk8.dim(`<${me.email}>`)}`);
       return "already";
     } catch (error) {
@@ -3152,20 +3344,13 @@ async function stepLogin(ctx, url) {
     }
   }
   try {
-    await runLogin({ ...ctx, json: false }, url);
+    await runLogin({ ...ctx, json: false }, serverUrl);
     return "done";
   } catch (error) {
     ctx.log.error(error instanceof Error ? error.message : String(error));
     return "failed";
   }
 }
-function safeNormalize(url) {
-  try {
-    return normalizeServerUrl(url);
-  } catch {
-    return void 0;
-  }
-}
 async function stepClaudeCode(ctx, run, scope, ask, fancy) {
   const status = await claudeCodeStatus(run);
   if (status.claude === "missing") {
@@ -3661,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.",
@@ -3675,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 {
@@ -3697,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) => `
@@ -3744,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})`;
@@ -3762,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,
@@ -3790,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
       })
     }
   );
@@ -3799,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)"
@@ -3809,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",
@@ -3872,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,
@@ -3907,7 +4237,6 @@ ${JSON.stringify(data, null, 2)}` }]
           listHtml: args.listHtml,
           retryWith: "fling_publish"
         });
-        return outcome;
       } finally {
         await rm2(tmp, { recursive: true, force: true });
       }
@@ -3916,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;
@@ -3932,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 = {
@@ -3947,57 +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 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 }),
@@ -4010,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 { isError: true, content: [{ type: "text", text: describeError(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 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,
@@ -4049,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 {
@@ -4068,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
@@ -4148,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 }
       };
     })
   );
@@ -4200,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;
@@ -4211,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());
 }
 
@@ -4266,7 +4696,10 @@ function routeOptionsFor(program2) {
 
 // src/cli.ts
 var program = new Command();
-program.name(BIN_NAME).description("Fling a folder of static files at Fling and get a link back").version(VERSION).option("--server <url>", `server URL (default: $${ENV.url}, else the one you logged in to)`).option("--json", "print JSON instead of human output", false).showHelpAfterError().configureHelp({
+program.name(BIN_NAME).description("Fling a folder of static files at Fling and get a link back").version(VERSION).option(
+  "--server <url>",
+  `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) => chalk10.bold(brand.primary(title)),
   styleCommandText: (text2) => chalk10.bold(text2),
@@ -4282,6 +4715,7 @@ program.name(BIN_NAME).description("Fling a folder of static files at Fling and
 ${chalk10.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
   $ ${BIN_NAME} deploy ./dist --name my-app \u2192 https://my-app.<your sites domain>
   $ ${BIN_NAME} ./dist                     the same: an existing path deploys
   $ ${BIN_NAME} ./dist --yes               no prompts (CI): use the generated name, fail if it is taken
@@ -4342,22 +4776,27 @@ program.command("deploy [path]").helpGroup("Deploy:").description(
   )
 );
 program.command("setup [url]").helpGroup("Setup:").description(
-  "sign in (to the Fling at url, the first time), then add the Fling plugin to Claude Code and the extension to Claude Desktop"
+  "sign in (to the Fling at url, which becomes current), then add the Fling plugin to Claude Code and the extension to Claude Desktop"
 ).option("-y, --yes", "do every step without asking").option("-s, --scope <scope>", "Claude Code plugin scope: user, project or local", "user").action(
   action(
     (ctx, url, opts) => runSetup(ctx, { ...opts, url })
   )
 );
 program.command("login [url]").helpGroup("Setup:").description(
-  "sign in through the browser to the Fling at url (remembered; later logins can omit it) and store an API key"
+  "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(
   action(async (ctx, url) => {
     await runLogin(ctx, url);
     ctx.log.hint(`Next: \`${BIN_NAME} setup\` adds Fling to Claude Code and Claude Desktop.`);
   })
 );
-program.command("logout").helpGroup("Setup:").description("remove the stored API key").action(action((ctx) => runLogout(ctx)));
-program.command("whoami").helpGroup("Setup:").description("show the signed-in user").action(action((ctx) => runWhoami(ctx)));
+program.command("use [url]").helpGroup("Setup:").description(
+  "switch to another Fling you signed in to (a URL or its host); without url, list them"
+).action(action((ctx, url) => runUse(ctx, url)));
+program.command("logout [url]").helpGroup("Setup:").description(
+  "remove a server's API key (default: the current server's, which stays current); any other server is forgotten"
+).action(action((ctx, url) => runLogout(ctx, url)));
+program.command("whoami").helpGroup("Setup:").description("show the signed-in user and the current server").action(action((ctx) => runWhoami(ctx)));
 program.commandsGroup("Setup:").helpCommand("help [command]", "show help for a command");
 program.command("ls").helpGroup("Sites:").alias("list").description("list your sites").option("--archived", "list archived sites").action(action((ctx, opts) => runList(ctx, opts)));
 program.command("info <name>").helpGroup("Sites:").description("show a site").action(action((ctx, name) => runInfo(ctx, name)));