@tyvm/knowhow 0.0.157 → 0.0.158

package/src/clients/pricing/fireworks.ts

@@ -11,6 +11,10 @@ import { ModelPricing, ModelCatalogEntry, completions, embeddings } from "./type
 export const FireworksModels = {
   // Moonshot AI
   KimiK3:      "accounts/fireworks/models/kimi-k3",
+
+  // Meta
+  MuseGlimmer30b: "accounts/fireworks/models/muse-glimmer-30b",
+
   KimiK2p7Code: "accounts/fireworks/models/kimi-k2p7-code",
   KimiK2_6:    "accounts/fireworks/models/kimi-k2-6",
   KimiK2_5:    "accounts/fireworks/models/kimi-k2-5",
@@ -22,6 +26,13 @@ export const FireworksModels = {
 
   // Qwen
   Qwen3p7Plus: "accounts/fireworks/models/qwen3p7-plus",
+  Qwen3p8Max:  "accounts/fireworks/models/qwen3p8-2p4t-a95b",
+
+  // NVIDIA
+  NemotronLightning3p530bA3b: "accounts/fireworks/models/nemotron-lightning-3p5-30b-a3b",
+
+  // Thinking Machines Lab
+  Inkling: "accounts/fireworks/models/inkling",
 
   // Deprecated Qwen Models
   Qwen3_6Plus:                "accounts/fireworks/models/qwen3-6-plus",
@@ -56,6 +67,10 @@ export const FireworksTextPricing: Record<string, ModelPricing> = {
   // Moonshot AI
   [FireworksModels.KimiK3]:       { input: 3.0, cache_hit: 0.30, output: 15.0 },
   [FireworksModels.KimiK2p7Code]: { input: 0.95, cache_hit: 0.19, output: 4.0 },
+
+  // Meta
+  [FireworksModels.MuseGlimmer30b]: { input: 0.35, cache_hit: 0.04, output: 1.50 },
+
   [FireworksModels.KimiK2_6]:     { input: 0.95, cache_hit: 0.16, output: 4.0 },
   [FireworksModels.KimiK2_5]:     { input: 0.60, cache_hit: 0.10, output: 3.0 },
 
@@ -67,6 +82,14 @@ export const FireworksTextPricing: Record<string, ModelPricing> = {
   // Qwen
   [FireworksModels.Qwen3p7Plus]:  { input: 0.40, cache_hit: 0.08, output: 1.60 },
 
+  [FireworksModels.Qwen3p8Max]:   { input: 2.00, cache_hit: 0.25, output: 6.00 },
+
+  // NVIDIA
+  [FireworksModels.NemotronLightning3p530bA3b]: { input: 0.05, cache_hit: 0.01, output: 0.20 },
+
+  // Thinking Machines Lab
+  [FireworksModels.Inkling]: { input: 1.00, cache_hit: 0.17, output: 4.05 },
+
   // Deprecated QWEN Models
   [FireworksModels.Qwen3_6Plus]:           { input: 0.50, cache_hit: 0.10, output: 3.0, deprecated: true },
   [FireworksModels.Qwen3p6Plus]:           { input: 0.50, cache_hit: 0.10, output: 3.0, deprecated: true },
@@ -81,8 +104,8 @@ export const FireworksTextPricing: Record<string, ModelPricing> = {
   [FireworksModels.Glm4_7]: { input: 0.60, cache_hit: 0.30, output: 2.20, deprecated: true },
 
   // DeepSeek AI
-  [FireworksModels.DeepseekV4Pro]:   { input: 1.74, cache_hit: 0.15, output: 3.48 },
-  [FireworksModels.DeepseekV4Flash]: { input: 0.14, cache_hit: 0.03, output: 0.28 },
+  [FireworksModels.DeepseekV4Pro]:   { input: 1.32, cache_hit: 0.044, output: 3.96 },
+  [FireworksModels.DeepseekV4Flash]: { input: 0.22, cache_hit: 0.007, output: 0.66 },
   [FireworksModels.DeepseekV3_2]:    { input: 0.56, cache_hit: 0.28, output: 1.68, deprecated: true },
   [FireworksModels.DeepseekV3_1]:    { input: 0.56, cache_hit: 0.28, output: 1.68, deprecated: true },
 
@@ -111,12 +134,19 @@ export const FireworksActiveTextModels: string[] = [
   FireworksModels.KimiK2p7Code,
   FireworksModels.KimiK2_6,
   FireworksModels.KimiK2_5,
+  // Meta
+  FireworksModels.MuseGlimmer30b,
   // MiniMax
   FireworksModels.MinimaxM3,
   FireworksModels.MinimaxM2_7,
   FireworksModels.MinimaxM2_5,
   // Qwen
   FireworksModels.Qwen3p7Plus,
+  FireworksModels.Qwen3p8Max,
+  // NVIDIA
+  FireworksModels.NemotronLightning3p530bA3b,
+  // Thinking Machines Lab
+  FireworksModels.Inkling,
   // Z.ai
   FireworksModels.Glm5p2,
   FireworksModels.Glm5p1,

package/src/commands/mcp.ts

@@ -273,6 +273,7 @@ export function addMcpCommands(program: Command): void {
         await listRemoteSecrets();
       }
     });
+
 }
 
 // ──────────────────────────────────────────────────────────────────────────────

package/src/commands/misc.ts

@@ -63,7 +63,7 @@ export function addLoginCommand(program: Command): void {
         return;
       }
 
-      await login(options.jwt, options.identity);
+      await login(options.jwt, options.identity, options.apiUrl);
     });
 }
 

package/src/commands/remote.ts

@@ -0,0 +1,77 @@
+import { Command } from "commander";
+import { getConfig, updateConfig } from "../config";
+import {
+  createRemote,
+  DEFAULT_API_URL,
+  DEFAULT_REMOTE_NAME,
+  getConfiguredRemotes,
+  registerRemote,
+} from "../remotes";
+
+export function addRemoteCommand(program: Command): void {
+  const command = program
+    .command("remote")
+    .description("Manage Knowhow API remotes");
+
+  command
+    .command("add")
+    .description("Register a Knowhow-compatible backend")
+    .argument("<name>", "Remote name")
+    .argument("<api-url>", "API base URL")
+    .action(async (name: string, apiUrl: string) => {
+      const config = await getConfig();
+      if (config.remotes?.[name]) {
+        throw new Error(`Remote '${name}' already exists.`);
+      }
+      const remote = createRemote(name, apiUrl);
+      registerRemote(config, remote);
+      await updateConfig(config);
+      console.log(`Added remote '${name}' (${remote.apiUrl}).`);
+    });
+
+  command
+    .command("use")
+    .description("Select the remote used by Knowhow commands in this configuration")
+    .argument("<name>", "Remote name")
+    .action(async (name: string) => {
+      const config = await getConfig();
+      const remote = getConfiguredRemotes(config)[name] ??
+        (name === DEFAULT_REMOTE_NAME ? createRemote(DEFAULT_REMOTE_NAME, DEFAULT_API_URL) : undefined);
+      if (!remote) {
+        throw new Error(`Unknown remote '${name}'. Add it with: knowhow remote add ${name} <api-url>`);
+      }
+      registerRemote(config, remote);
+      config.activeRemote = name;
+      await updateConfig(config);
+      console.log(`Using remote '${name}' (${remote.apiUrl}).`);
+    });
+
+  command
+    .command("list")
+    .alias("ls")
+    .description("List configured remotes")
+    .action(async () => {
+      const config = await getConfig();
+      const remotes = { ...getConfiguredRemotes(config) };
+      if (!remotes[DEFAULT_REMOTE_NAME]) {
+        remotes[DEFAULT_REMOTE_NAME] = createRemote(DEFAULT_REMOTE_NAME, DEFAULT_API_URL);
+      }
+      for (const [name, remote] of Object.entries(remotes)) {
+        const marker = (config.activeRemote ?? DEFAULT_REMOTE_NAME) === name ? "*" : " ";
+        console.log(`${marker} ${name}\t${remote.apiUrl}\t${remote.jwtPath}${remote.orgId ? `\t${remote.orgId}` : ""}`);
+      }
+    });
+
+  command
+    .command("get-url")
+    .description("Print a remote API URL")
+    .argument("[name]", "Remote name")
+    .action(async (name?: string) => {
+      const config = await getConfig();
+      const selectedName = name ?? config.activeRemote ?? DEFAULT_REMOTE_NAME;
+      const remote = getConfiguredRemotes(config)[selectedName] ??
+        (selectedName === DEFAULT_REMOTE_NAME ? createRemote(DEFAULT_REMOTE_NAME, DEFAULT_API_URL) : undefined);
+      if (!remote) throw new Error(`Unknown remote '${selectedName}'.`);
+      console.log(remote.apiUrl);
+    });
+}

package/src/config.ts

@@ -4,7 +4,6 @@ import * as os from "os";
 import gitignoreToGlob from "gitignore-to-glob";
 import { Prompts } from "./prompts";
 import { promisify } from "util";
-import { KNOWHOW_API_URL } from "./services/KnowhowClient";
 import {
   Config,
   SourceRef,
@@ -113,6 +112,15 @@ const defaultConfig = {
     },
   },
 
+  activeRemote: "origin",
+  remotes: {
+    origin: {
+      name: "origin",
+      apiUrl: "https://api.knowhow.tyvm.ai",
+      jwtPath: ".knowhow/.jwt",
+    },
+  },
+
   syncRemote: false,
 } as Config;
 

package/src/login.ts

@@ -8,6 +8,16 @@ import { KNOWHOW_API_URL } from "./services/KnowhowClient";
 import { BrowserLoginService } from "./auth/browserLogin";
 import { authenticateWithKey, hasKeyPair, registerPublicKey } from "./auth/keyAuth";
 import { getDefaultPrivateKeyPath, getOrCreatePublicKey } from "./auth/keyManager";
+import { storeJwtForApi } from "./auth/jwtStore";
+import { getOrgIdForApi, setOrgIdForApi } from "./auth/environmentAuth";
+import {
+  createRemote,
+  findRemoteForApi,
+  inferRemoteName,
+  registerRemote,
+  resolveJwtPath,
+} from "./remotes";
+import { KnowhowRemote } from "./types";
 
 /**
  * Log in to Knowhow.
@@ -23,37 +33,31 @@ import { getDefaultPrivateKeyPath, getOrCreatePublicKey } from "./auth/keyManage
  * @param jwtFlag      True when --jwt flag is passed.
  * @param identityPath Optional path to a specific private key file (--identity flag).
  */
-export async function login(jwtFlag?: boolean, identityPath?: string): Promise<void> {
-  if (!KNOWHOW_API_URL) {
-    throw new Error("Error: KNOWHOW_API_URL environment variable not set.");
-  }
+export async function login(
+  jwtFlag?: boolean,
+  identityPath?: string,
+  apiUrl: string = KNOWHOW_API_URL,
+  remoteName?: string
+): Promise<void> {
+  const config = await getConfig();
+  const remote = findRemoteForApi(config, apiUrl) ??
+    createRemote(remoteName ?? inferRemoteName(apiUrl), apiUrl);
 
   if (jwtFlag) {
     const jwt = await ask("Enter your JWT: ");
-
-    const configDir = path.join(process.cwd(), ".knowhow");
-    const jwtFile = path.join(configDir, ".jwt");
-
-    if (!fs.existsSync(configDir)) {
-      fs.mkdirSync(configDir, { recursive: true });
-    }
-    fs.writeFileSync(jwtFile, jwt);
-    fs.chmodSync(jwtFile, 0o600);
-    console.log("JWT updated successfully.");
+    const jwtFile = storeJwtForApi(jwt, remote.apiUrl, remote.jwtPath);
+    console.log(`JWT updated successfully in ${path.relative(process.cwd(), jwtFile)}.`);
   } else {
     const selectedIdentityPath = identityPath ?? getDefaultPrivateKeyPath();
-    const config = await getConfig();
-    const orgId = config.orgId;
+    const orgId = getOrgIdForApi(config, remote.apiUrl);
 
-    // A local key is not proof of registration. Let the selected environment
-    // check it, but only when an organization is available to bind the attempt.
     if (orgId && hasKeyPair(selectedIdentityPath)) {
       console.log("Found CLI identity — authenticating with public key...");
       try {
-        const success = await authenticateWithKey(orgId, KNOWHOW_API_URL, selectedIdentityPath);
+        const success = await authenticateWithKey(orgId, remote.apiUrl, selectedIdentityPath);
         if (success) {
           console.log("✅ Successfully authenticated via public key!");
-          return await postLoginConfigUpdate(selectedIdentityPath);
+          return await postLoginConfigUpdate(remote, selectedIdentityPath);
         }
         console.warn("Key authentication returned no JWT, falling back to browser login...");
       } catch (error: unknown) {
@@ -62,30 +66,31 @@ export async function login(jwtFlag?: boolean, identityPath?: string): Promise<v
       }
     }
 
-    // Fall back when no org/key is configured or when key auth is unavailable.
-    await doBrowserLogin(selectedIdentityPath);
+    await doBrowserLogin(remote, selectedIdentityPath, orgId);
     identityPath = selectedIdentityPath;
   }
 
-  await postLoginConfigUpdate(identityPath);
+  await postLoginConfigUpdate(remote, identityPath);
 }
 
 /** Complete browser PKCE, then best-effort bootstrap the selected identity. */
-async function doBrowserLogin(identityPath?: string): Promise<void> {
+async function doBrowserLogin(
+  remote: KnowhowRemote,
+  identityPath?: string,
+  orgId?: string
+): Promise<void> {
   console.log("Starting browser-based authentication...");
   try {
-    const existingConfig = await getConfig();
-    const existingOrgId = existingConfig?.orgId;
-    const browserLoginService = new BrowserLoginService(undefined, existingOrgId);
+    const browserLoginService = new BrowserLoginService(remote.apiUrl, orgId);
     await browserLoginService.login();
     console.log("✅ Successfully authenticated via browser!");
 
     try {
       const keyPair = getOrCreatePublicKey(identityPath);
       await registerPublicKey(
-        await loadJwt(),
+        await loadJwt(remote),
         keyPair.publicKeyBase64,
-        KNOWHOW_API_URL
+        remote.apiUrl
       );
       console.log(`Registered CLI identity ${keyPair.fingerprint}`);
     } catch (registrationError: unknown) {
@@ -114,10 +119,13 @@ function isTemporaryIdentityPath(identityPath: string): boolean {
 }
 
 /** After any successful login, update the local config with the current user/org. */
-async function postLoginConfigUpdate(identityPath?: string): Promise<void> {
+async function postLoginConfigUpdate(
+  remote: KnowhowRemote,
+  identityPath?: string
+): Promise<void> {
   try {
-    const storedJwt = await loadJwt();
-    const { user, currentOrg } = await checkJwt(storedJwt);
+    const storedJwt = await loadJwt(remote);
+    const { user, currentOrg } = await checkJwt(storedJwt, remote.apiUrl);
     const orgId = currentOrg?.organizationId;
 
     console.log(
@@ -137,8 +145,10 @@ async function postLoginConfigUpdate(identityPath?: string): Promise<void> {
       config.modelProviders.push({ provider: "knowhow" });
     }
 
+    registerRemote(config, orgId ? { ...remote, orgId } : remote);
+    config.activeRemote = remote.name;
     if (orgId) {
-      config.orgId = orgId;
+      setOrgIdForApi(config, remote.apiUrl, orgId);
     }
 
     if (identityPath && !isTemporaryIdentityPath(identityPath)) {
@@ -164,23 +174,25 @@ async function postLoginConfigUpdate(identityPath?: string): Promise<void> {
   }
 }
 
-export async function loadJwt(): Promise<string> {
-  const jwtFile = path.join(process.cwd(), ".knowhow", ".jwt");
-  if (!fs.existsSync(jwtFile)) {
-    throw new Error("Error: JWT file not found.");
-  }
-
-  const jwt = fs.readFileSync(jwtFile, "utf-8").trim();
+export async function loadJwt(remote?: KnowhowRemote): Promise<string> {
+  const selectedRemote = remote ??
+    findRemoteForApi(await getConfig(), KNOWHOW_API_URL) ??
+    createRemote(inferRemoteName(KNOWHOW_API_URL), KNOWHOW_API_URL);
+  const jwtFile = resolveJwtPath(selectedRemote.jwtPath);
+  const jwt = fs.existsSync(jwtFile) ? fs.readFileSync(jwtFile, "utf8").trim() : "";
 
   if (!jwt) {
+    if (!fs.existsSync(jwtFile)) {
+      throw new Error(`Error: JWT file not found: ${jwtFile}`);
+    }
     throw new Error("Error: JWT is empty. Re-login with knowhow login --jwt.");
   }
 
   return jwt;
 }
 
-export async function checkJwt(storedJwt: string) {
-  const response = await http.get(`${KNOWHOW_API_URL}/api/users/me`, {
+export async function checkJwt(storedJwt: string, apiUrl: string = KNOWHOW_API_URL) {
+  const response = await http.get(`${apiUrl}/api/users/me`, {
     headers: {
       Authorization: `Bearer ${storedJwt}`,
     },

package/src/remotes.ts

@@ -0,0 +1,110 @@
+import fs from "fs";
+import path from "path";
+import { Config, KnowhowRemote } from "./types";
+
+export const DEFAULT_REMOTE_NAME = "origin";
+export const DEFAULT_API_URL = "https://api.knowhow.tyvm.ai";
+
+export function normalizeApiUrl(apiUrl: string): string {
+  const trimmed = apiUrl.trim().replace(/\/+$/, "");
+  const url = new URL(trimmed);
+  if (!/^https?:$/.test(url.protocol)) {
+    throw new Error(`Remote URL must use http or https: ${apiUrl}`);
+  }
+  return url.toString().replace(/\/$/, "");
+}
+
+export function defaultJwtPath(apiUrl: string): string {
+  const normalized = normalizeApiUrl(apiUrl);
+  if (normalized === DEFAULT_API_URL) return ".knowhow/.jwt";
+  const { hostname, port } = new URL(normalized);
+  let suffix: string;
+  if (hostname === "localhost" || hostname === "::1" || hostname.startsWith("127.")) {
+    suffix = "local";
+  } else if (hostname === "api.dev.knowhow.tyvm.ai" || hostname.includes(".dev.")) {
+    suffix = "dev";
+  } else {
+    suffix = `${hostname}${port ? `-${port}` : ""}`
+      .toLowerCase()
+      .replace(/[^a-z0-9.-]+/g, "-")
+      .replace(/^-+|-+$/g, "");
+  }
+  return `.knowhow/.jwt.${suffix}`;
+}
+
+export function createRemote(name: string, apiUrl: string): KnowhowRemote {
+  if (!/^[a-zA-Z0-9._-]+$/.test(name)) {
+    throw new Error("Remote names may only contain letters, numbers, '.', '_' and '-'.");
+  }
+  const normalizedUrl = normalizeApiUrl(apiUrl);
+  return { name, apiUrl: normalizedUrl, jwtPath: defaultJwtPath(normalizedUrl) };
+}
+
+export function getConfiguredRemotes(config: Config): Record<string, KnowhowRemote> {
+  return config.remotes ?? {};
+}
+
+export function findRemoteForApi(config: Config, apiUrl: string): KnowhowRemote | undefined {
+  const normalizedUrl = normalizeApiUrl(apiUrl);
+  return Object.values(getConfiguredRemotes(config)).find(
+    (remote) => normalizeApiUrl(remote.apiUrl) === normalizedUrl
+  );
+}
+
+export function findRemoteForApiSync(apiUrl: string): KnowhowRemote | undefined {
+  try {
+    const config = JSON.parse(
+      fs.readFileSync(path.join(process.cwd(), ".knowhow", "knowhow.json"), "utf8")
+    ) as Config;
+    return findRemoteForApi(config, apiUrl);
+  } catch {
+    return undefined;
+  }
+}
+
+export function getActiveRemote(config: Config): KnowhowRemote {
+  const envUrl = process.env.KNOWHOW_API_URL;
+  if (envUrl) {
+    return findRemoteForApi(config, envUrl) ?? createRemote(inferRemoteName(envUrl), envUrl);
+  }
+  const name = config.activeRemote ?? DEFAULT_REMOTE_NAME;
+  return config.remotes?.[name] ?? createRemote(DEFAULT_REMOTE_NAME, DEFAULT_API_URL);
+}
+
+export function getActiveRemoteSync(): KnowhowRemote {
+  try {
+    const config = JSON.parse(
+      fs.readFileSync(path.join(process.cwd(), ".knowhow", "knowhow.json"), "utf8")
+    ) as Config;
+    return getActiveRemote(config);
+  } catch {
+    const apiUrl = process.env.KNOWHOW_API_URL ?? DEFAULT_API_URL;
+    return createRemote(inferRemoteName(apiUrl), apiUrl);
+  }
+}
+
+export function registerRemote(config: Config, remote: KnowhowRemote): void {
+  const migratedRemotes: Record<string, KnowhowRemote> = {};
+  for (const [apiUrl, orgId] of Object.entries(config.orgIds ?? {})) {
+    const name = inferRemoteName(apiUrl);
+    migratedRemotes[name] = {
+      ...createRemote(name, apiUrl),
+      orgId,
+    };
+  }
+  config.remotes = { ...migratedRemotes, ...(config.remotes ?? {}), [remote.name]: remote };
+  delete config.orgIds;
+}
+
+export function inferRemoteName(apiUrl: string): string {
+  const normalized = normalizeApiUrl(apiUrl);
+  if (normalized === DEFAULT_API_URL) return DEFAULT_REMOTE_NAME;
+  const { hostname } = new URL(normalized);
+  if (hostname === "localhost" || hostname === "::1" || hostname.startsWith("127.")) return "local";
+  if (hostname === "api.dev.knowhow.tyvm.ai" || hostname.includes(".dev.")) return "dev";
+  return hostname.toLowerCase().replace(/[^a-z0-9.-]+/g, "-");
+}
+
+export function resolveJwtPath(jwtPath: string): string {
+  return path.resolve(process.cwd(), jwtPath);
+}

package/src/services/KnowhowClient.ts

@@ -5,8 +5,10 @@ import fs from "fs";
 import { getConfigSync } from "../config";
 import { exchangeAvailablePublicKeyJwt, storeJwt } from "../auth/keyAuth";
 import { keyPairExists } from "../auth/keyManager";
+import { getOrgIdForApi } from "../auth/environmentAuth";
+import { loadJwtFromDisk } from "../auth/jwtStore";
+import { getActiveRemoteSync } from "../remotes";
 import { Message } from "../clients/types";
-import path from "path";
 import {
   CompletionOptions,
   CompletionResponse,
@@ -125,7 +127,7 @@ export interface GitCredentialResponse {
   expiresAt: string | null;
 }
 
-export function loadKnowhowJwt(): string {
+export function loadKnowhowJwt(apiUrl: string = KNOWHOW_API_URL): string {
   // Check env var first — this is how cloud workers/CI runners get auth
   // (injected via KNOWHOW_JWT env var in the runner's .env file by GithubRunnerService).
   // This avoids depending on a potentially stale .knowhow/.jwt file from the snapshot.
@@ -133,17 +135,10 @@ export function loadKnowhowJwt(): string {
     return process.env.KNOWHOW_JWT;
   }
 
-  const jwtFile = path.join(process.cwd(), ".knowhow", ".jwt");
-  if (!fs.existsSync(jwtFile)) {
-    return "";
-  }
-  const jwt = fs.readFileSync(jwtFile, "utf-8").trim();
-
-  return jwt;
+  return loadJwtFromDisk(apiUrl);
 }
 
-export const KNOWHOW_API_URL =
-  process.env.KNOWHOW_API_URL || "https://api.knowhow.tyvm.ai";
+export const KNOWHOW_API_URL = getActiveRemoteSync().apiUrl;
 
 @TraceAll()
 export class KnowhowSimpleClient {
@@ -159,7 +154,7 @@ export class KnowhowSimpleClient {
     // Explicit tokens (including KNOWHOW_JWT worker credentials) have no
     // corresponding local identity and must never trigger interactive renewal.
     this.canRefreshJwt = jwt === undefined && !process.env.KNOWHOW_JWT;
-    this.jwt = jwt ?? loadKnowhowJwt();
+    this.jwt = jwt ?? loadKnowhowJwt(this.baseUrl);
     this.setJwt(this.jwt);
     if (this.canRefreshJwt) {
       Object.defineProperty(this.headers, HTTP_UNAUTHORIZED_HANDLER, {
@@ -175,7 +170,7 @@ export class KnowhowSimpleClient {
    * Reload the JWT from disk (useful after login refreshes the token).
    */
   refreshJwt() {
-    const freshJwt = loadKnowhowJwt();
+    const freshJwt = loadKnowhowJwt(this.baseUrl);
     if (freshJwt) {
       this.setJwt(freshJwt);
       this.jwtValidated = false;
@@ -206,12 +201,13 @@ export class KnowhowSimpleClient {
     this.refreshPromise = (async () => {
       const config = getConfigSync();
       const identityPath = config.cliIdentityPath;
-      if (!config.orgId || (!keyPairExists(identityPath) && !keyPairExists())) {
+      const orgId = getOrgIdForApi(config, this.baseUrl);
+      if (!orgId || (!keyPairExists(identityPath) && !keyPairExists())) {
         throw new Error("JWT expired and the CLI identity is unavailable. Please run `knowhow login` again.");
       }
       try {
-        const freshJwt = await exchangeAvailablePublicKeyJwt(config.orgId, this.baseUrl, identityPath);
-        storeJwt(freshJwt);
+        const freshJwt = await exchangeAvailablePublicKeyJwt(orgId, this.baseUrl, identityPath);
+        storeJwt(freshJwt, this.baseUrl);
         this.setJwt(freshJwt);
         this.jwtValidated = true;
       } catch (error) {