@nearform/fling 0.3.0 → 0.4.0

package/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 ## Unreleased
 
+## 0.4.0
+
+- **Several Flings.** The CLI remembers every Fling you sign in to, each with its own API key, and
+  uses the current one. `fling login <url>` and `fling setup <url>` add a Fling (or refresh its
+  login) and make it current without signing you out of the others. `fling use` lists them, with
+  each one's name and your email; `fling use <url>` switches (a full address, its host or the start
+  of it). `fling logout <url>` signs out of another Fling and forgets it; a bare `fling logout`
+  still removes the current Fling's key and keeps the Fling. `fling whoami` shows which Fling is
+  current.
+- `--server` and `FLING_URL` pick a remembered Fling for one command and use its stored key (an
+  address you haven't signed in to has no key; `FLING_API_KEY` still overrides). The local MCP
+  server uses the current Fling unless `FLING_URL` (the Claude Desktop extension's **Fling server**)
+  names one, and signing in from it makes that Fling current only when no other is.
+- Upgrading: `~/.fling/config.json` from 0.3 is read as-is, as one remembered Fling that is
+  current. It is rewritten in the new shape (`current` plus `servers`, keyed by address) the next
+  time the CLI saves it, so an older CLI can no longer read it after that.
+
 ## 0.3.0
 
 **Breaking: no default server.** The CLI works with any Fling deployment, so it no longer has one

package/README.md

@@ -35,6 +35,7 @@ This does everything a new machine needs:
 1. **Signs you in.** The CLI reads the server's `/.well-known/fling` (its name, where its sites
    live, how people sign in) and remembers it. Your browser opens for sign-in and an API key is
    stored in `~/.fling/config.json` (mode 0600). This is skipped if you're already signed in.
+   The server becomes your current one; logins to other Flings are kept.
 2. **Adds Fling to Claude Code.** If `claude` is on your PATH, setup installs the Fling plugin
    (skill + MCP server) from the `nearform/fling` marketplace, or updates it if it's already
    installed. `--scope project|local` installs it for this project only (default `user`).
@@ -45,8 +46,25 @@ On a terminal it asks before steps 2 and 3. With `--yes` it does them without as
 
 To sign in only, use `fling login <url>` (the URL is remembered: later `fling login` needs none).
 There is no default server: until you log in, commands say to run `fling login <url>`.
-`fling whoami` shows who you are, and `fling logout` removes the key (and keeps the server). For CI,
-set `FLING_URL` and `FLING_API_KEY` instead.
+`fling whoami` shows who you are and which server is current. For CI, set `FLING_URL` and
+`FLING_API_KEY` instead.
+
+### Several Flings
+
+The CLI remembers every Fling you sign in to, each with its own key, and uses the current one.
+`fling login <url>` or `fling setup <url>` adds a Fling (or signs in to it again) and makes it
+current; the others stay signed in.
+
+```sh
+fling use                              # list them: * marks the current one, with its name and your email
+fling use other.example.com            # switch: a full address, its host, or the start of it
+fling --server other.example.com ls    # one command against another Fling, with its own key
+```
+
+`FLING_URL` picks a Fling the same way for every command run with it, and `FLING_API_KEY`
+overrides the stored key. `fling logout` removes the current Fling's key and keeps it current (a
+bare `fling login` signs in again); `fling logout <url>` signs out of another Fling and forgets
+it.
 
 ## Deploy
 
@@ -186,7 +204,7 @@ feedback (`reviewUrl` in `--json`); reviewers sign in to use it.
 | `fling uncomment <name> <id> [--yes]` | delete a comment (a thread with its replies): your own, or any on your site |
 
 Global options: `--json` prints machine-readable output, and `--server <url>` points one command at
-another server. Exit codes are `0` ok, `1` error, `2` not logged in and `3` forbidden.
+another server (a remembered one brings its key; see [Several Flings](#several-flings)). Exit codes are `0` ok, `1` error, `2` not logged in and `3` forbidden.
 
 Environment: `FLING_API_KEY`, `FLING_URL`, `FLING_CONFIG_DIR`, `FLING_DEBUG`, `FLING_DOWNLOADS_DIR`
 (where the MCP server looks for files given by name first), `FLING_NO_WAIT=1` (after a deploy or a new share
@@ -210,7 +228,8 @@ Or install it by hand in Claude Code:
 
 Log in once with `fling login <url>` (or `npx @nearform/fling login <url>` if it is not installed).
 The MCP server reuses that login, and its tool descriptions name your Fling and where its sites
-live.
+live. It re-reads the config on every call, so after `fling use <url>` it talks to the new current
+Fling without a restart.
 
 The MCP tools:
 
@@ -246,8 +265,10 @@ without uploading anything from Claude's sandbox.
 3. Optional settings: **Fling server** (filled in with the Fling you downloaded it from; empty means
    the one the CLI is logged in to) and **Downloads folder** (default `~/Downloads`).
 4. Ask Claude to "fling Pitch Deck.html from my Downloads". If you're not signed in, Claude calls
-   `fling_login` and your browser opens. The extension and the CLI share the login in
-   `~/.fling/config.json`.
+   `fling_login` and your browser opens. The extension and the CLI share the logins in
+   `~/.fling/config.json`. With **Fling server** set, the extension always uses that Fling (and its
+   stored key), whichever one the CLI is using; signing in from the extension doesn't change the
+   CLI's current Fling.
 
 It needs Node.js 20 or later, which Claude Desktop provides, on macOS or Windows.
 

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.4.0",
   license: "MIT",
   description: "Fling a folder of static files at a Fling server and get a link back. CLI + MCP server.",
   type: "module",
@@ -1310,16 +1310,15 @@ var ENV = {
   /** Where to look for files given by name (the .mcpb extension sets it from its settings). */
   downloadsDir: "FLING_DOWNLOADS_DIR"
 };
-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 };
@@ -1331,6 +1330,37 @@ function fromEnv(value) {
 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 +1370,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 +1379,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 +1525,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 +1558,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 +2042,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 +2163,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 +3293,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 +3312,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 +3339,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") {
@@ -3987,6 +4167,8 @@ ${JSON.stringify(data, null, 2)}` }]
             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.
+            makeCurrent: !config.current || config.current === serverUrl,
             onAuthUrl: (url) => {
               login.url = url;
             }
@@ -4266,7 +4448,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 +4467,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 +4528,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)));