@synqa/cli 1.1.0 → 1.2.0

package/dist/providers.js

@@ -0,0 +1,234 @@
+// Providers: Synqa Cloud is the primary one and unlocks first; the others are the user's own
+// accounts (OpenCode Go and Zen, a bring-your-own router key, any OpenAI-compatible endpoint).
+// Their credentials are stored in the private config file and sent only to that provider's URL.
+import { checkKey } from "./api.js";
+                                          
+import { fetchAccount } from "./account.js";
+import { API_BASE, looksLikeKey, readConfig, resolveApiKey, resolveProviderKey, saveProvider, writeConfig } from "./config.js";
+import { sanitize, sanitizeModelId } from "./sanitize.js";
+import { TIERS } from "./tiers.js";
+                                            
+
+                                                                                            
+
+                                                                                           
+
+export const PROVIDERS                         = [
+  { id: "synqa", name: "Synqa Cloud", label: "Synqa Cloud (Blink 5.5 · Sonata 6.0 · Aeon 6.5) [Primary]", baseUrl: API_BASE },
+  { id: "opencode-go", name: "OpenCode Go", label: "OpenCode Go (Subscription models via OpenCode)", baseUrl: "https://opencode.ai/zen/v1" },
+  { id: "opencode-zen", name: "OpenCode Zen", label: "OpenCode Zen (Pay-as-you-go via OpenCode)", baseUrl: "https://opencode.ai/zen/v1" },
+  { id: "openrouter", name: "OpenRouter", label: "OpenRouter (Bring your own sk-or-... key)", baseUrl: "https://openrouter.ai/api/v1" },
+  { id: "custom", name: "Custom endpoint", label: "Custom OpenAI-Compatible Endpoint", baseUrl: "" },
+];
+
+export const providerDef = (id        )                          => PROVIDERS.find((p) => p.id === id);
+
+// Shown only when the provider's own /v1/models list cannot be fetched.
+export const CURATED_MODELS                                    = {
+  "opencode-go": ["kimi-k2", "grok-code"],
+  "opencode-zen": ["grok-code", "kimi-k2"],
+  openrouter: ["openrouter/auto", "moonshotai/kimi-k2", "x-ai/grok-code-fast-1"],
+  custom: [],
+};
+
+// What /model offers. On Synqa Cloud it is the three tiers (the short id after the name); on the
+// others it is the fetched list, or the curated defaults when nothing could be fetched.
+export function modelItems(provider        , fetched                    )                     {
+  if (provider === "synqa") {
+    return TIERS.map((t) => ({ label: `${t.display} (${t.id.replace(/-\d+(\.\d+)*$/, "")})`, value: t.key }));
+  }
+  const ids = fetched && fetched.length ? fetched : CURATED_MODELS[provider] ?? [];
+  return ids.slice(0, 200).map((id) => ({ label: id, value: id }));
+}
+
+const trimSlash = (u        ) => u.replace(/\/+$/, "");
+
+// GET {base}/models. Returns the model ids; throws a short, sanitized message on failure.
+export async function fetchModelIds(baseUrl        , secret        , fetchFn            = fetch, timeoutMs = 8000)                    {
+  const ac = new AbortController();
+  const timer = setTimeout(() => ac.abort(), timeoutMs);
+  try {
+    const res = await fetchFn(`${trimSlash(baseUrl)}/models`, { headers: { authorization: `Bearer ${secret}` }, signal: ac.signal });
+    if (res.status === 401 || res.status === 403) throw new Error("the key was rejected");
+    if (!res.ok) throw new Error(`the provider answered with status ${res.status}`);
+    const body = (await res.json())                      ;
+    const data = Array.isArray(body.data) ? body.data : [];
+    return data
+      .map((m) => (m && typeof m === "object" ? (m                    ).id : undefined))
+      .filter((id)               => typeof id === "string" && id.length > 0 && id.length <= 200)
+      .map((id) => sanitize(id));
+  } catch (err) {
+    if (ac.signal.aborted) throw new Error("the provider did not answer in time");
+    throw new Error(sanitize(err instanceof Error ? err.message : String(err)));
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// A base URL a person typed: http(s) only, no credentials in it, no query or fragment.
+export function normalizeBaseUrl(raw        )                     {
+  try {
+    const u = new URL(raw.trim());
+    if (u.protocol !== "https:" && u.protocol !== "http:") return undefined;
+    // The key travels in a header: plain http only to this machine.
+    if (u.protocol === "http:" && !["localhost", "127.0.0.1", "[::1]"].includes(u.hostname)) return undefined;
+    if (u.username || u.password || u.search || u.hash) return undefined;
+    return trimSlash(u.toString());
+  } catch {
+    return undefined;
+  }
+}
+
+// Verifies a Synqa key against GET /v1/account (the models list when the account route is not
+// available to keys yet). Returns undefined when the key is good, else a short reason.
+export async function verifySynqaKey(candidate        , fetchFn            )                              {
+  if (!looksLikeKey(candidate)) return "That does not look like a Synqa key (expected synqa_live_...).";
+  const r = await fetchAccount(candidate, fetchFn, 8000);
+  if (r.ok) return undefined;
+  if (r.notFound) {
+    try {
+      await checkKey(candidate, fetchFn);
+      return undefined;
+    } catch (err) {
+      return `Could not verify the key: ${sanitize(err instanceof Error ? err.message : String(err))}`;
+    }
+  }
+  return `Could not verify the key: ${sanitize(r.message)}`;
+}
+
+                                                     
+
+// The synqa-first gate: nothing else unlocks until a valid Synqa Cloud key is saved. `secret`
+// reads masked input (undefined = cancelled). Returns the key, or undefined when cancelled or
+// out of attempts (the TUI stays locked).
+export async function unlockGate(o   
+                                                          
+                             
+            
+                      
+                    
+ )                              {
+  const env = o.env ?? process.env;
+  for (let i = 0; i < (o.attempts ?? 3); i++) {
+    const entered = await o.secret("Synqa Cloud API key (synqa_live_...): ");
+    if (entered === undefined) return undefined;
+    const why = await verifySynqaKey(entered, o.fetchFn);
+    if (why) { o.print(why); continue; }
+    writeConfig({ ...readConfig(env), apiKey: entered }, env);
+    return entered;
+  }
+  o.print("Too many attempts. Run synqa again to sign in.");
+  return undefined;
+}
+
+                               
+                                                      
+                         
+                  
+                                                                                                
+  
+
+                          
+                             
+                                                                                     
+                                                          
+                                                       
+                      
+            
+                                                                      
+  
+
+// Makes `id` the active provider. For a secondary one it asks for the key when none is saved,
+// verifies it with GET /models, stores it and picks a first model. Returns false when cancelled.
+export async function activateProvider(st                 , id            , io            )                   {
+  const env = io.env ?? process.env;
+  const def = providerDef(id)               ;
+  if (id === "synqa") {
+    const saved = resolveApiKey(env, { envKey: io.envKey });
+    if (!saved) { io.print("Not signed in to Synqa Cloud."); return false; }
+    st.apiKey = saved; st.providerId = "synqa"; st.baseUrl = API_BASE; st.modelId = undefined;
+    writeConfig({ ...readConfig(env), activeProvider: "synqa" }, env);
+    io.print("Using Synqa Cloud.");
+    return true;
+  }
+  const entry = readConfig(env).providers?.[id];
+  let baseUrl = def.baseUrl;
+  let model = entry?.model;
+  if (id === "custom") {
+    const raw = entry?.baseUrl ?? (await io.ask("Base URL (for example https://host/v1): "));
+    if (raw === undefined) return false;
+    const norm = normalizeBaseUrl(raw);
+    if (!norm) { io.print("That is not a usable base URL (https, or http for localhost only)."); return false; }
+    baseUrl = norm;
+  }
+  let credential = resolveProviderKey(id, env, { envKey: io.envKey });
+  if (!credential) {
+    credential = await io.secret(`${def.name} API key: `);
+    if (!credential) { io.print("Cancelled."); return false; }
+  }
+  let ids           = [];
+  try {
+    ids = await fetchModelIds(baseUrl, credential, io.fetchFn);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    // A custom endpoint may not serve /models at all; a rejected key is always final.
+    if (id !== "custom" || /rejected/.test(msg)) { io.print(`Could not verify the key: ${msg}`); return false; }
+    io.print(`Could not list models (${msg}); continuing.`);
+  }
+  if (id === "custom" && !model) {
+    const m = await io.ask("Model ID: ");
+    if (!m) { io.print("Cancelled."); return false; }
+    model = sanitizeModelId(m);
+    if (!model) { io.print("That is not a usable model id."); return false; }
+  }
+  if (!model) model = modelItems(id, ids)[0]?.value;
+  saveProvider(id, { apiKey: credential, ...(id === "custom" ? { baseUrl } : {}), ...(model ? { model } : {}) }, env);
+  writeConfig({ ...readConfig(env), activeProvider: id }, env);
+  st.apiKey = credential; st.providerId = id; st.baseUrl = baseUrl; st.modelId = model;
+  io.print(`Using ${def.name}${model ? ` with ${model}` : ""}.`);
+  return true;
+}
+
+// /provider and /login: the arrow-key menu.
+export async function providerMenu(st                 , io            , arg = "")                   {
+  const wanted = arg.trim().toLowerCase();
+  let id                         = PROVIDERS.find((p) => p.id === wanted)?.id;
+  if (!id) {
+    const items = PROVIDERS.map((p) => ({ label: p.label, value: p.id, hint: p.id === st.providerId ? "(active)" : undefined }));
+    id = await io.pick(items, "Choose a provider");
+  }
+  if (!id) { io.print("Cancelled."); return false; }
+  return activateProvider(st, id, io);
+}
+
+                                                
+
+// /logout. Returns "locked" after a full logout (the caller returns to the sign-in prompt),
+// "secondary" after leaving a secondary provider, or undefined when nothing changed.
+export async function logout(st                 , io            )                                              {
+  const env = io.env ?? process.env;
+  const choice = await io.pick              ([
+    { label: "Log out of active secondary provider", value: "secondary" },
+    { label: "Full logout (clear Synqa key and lock TUI)", value: "full" },
+  ], "Log out");
+  if (!choice) { io.print("Cancelled."); return undefined; }
+  const cfg = readConfig(env);
+  if (choice === "secondary") {
+    if (st.providerId === "synqa") { io.print("No secondary provider is active."); return undefined; }
+    const providers = { ...cfg.providers };
+    delete providers[st.providerId];
+    const synqaKey = cfg.apiKey?.trim() || env.SYNQA_API_KEY?.trim() || "";
+    writeConfig({ ...cfg, providers, activeProvider: "synqa" }, env);
+    st.providerId = "synqa"; st.baseUrl = API_BASE; st.modelId = undefined; st.apiKey = synqaKey;
+    io.print("Logged out of the secondary provider. Using Synqa Cloud.");
+    return "secondary";
+  }
+  const next = { ...cfg, activeProvider: "synqa" };
+  delete next.apiKey;
+  writeConfig(next, env);
+  // The variable is cleared in this process only, so nobody has to unset it in their shell.
+  delete env.SYNQA_API_KEY;
+  st.apiKey = ""; st.providerId = "synqa"; st.baseUrl = API_BASE; st.modelId = undefined;
+  io.print("Logged out of Synqa Cloud. The session is locked until you sign in again.");
+  return "locked";
+}

package/dist/sanitize.js

@@ -51,3 +51,9 @@ export function fenceText(s        , max        )         {
     .slice(0, max)
     .replace(/</g, "\u2039");
 }
+
+// A model id a person typed or a provider listed: letters, digits and . _ : / @ + - only, 200 at most.
+export function sanitizeModelId(s        )                     {
+  const t = s.trim();
+  return /^[A-Za-z0-9._:\/@+-]{1,200}$/.test(t) ? t : undefined;
+}

package/dist/select.js

@@ -0,0 +1,131 @@
+// Inline terminal controls that take over the keyboard for a moment: an Up/Down selector (pickOne)
+// and a masked secret prompt (readMasked). Both read keys from a KeySource and write to a plain
+// { write } sink, so they are tested with a fake source and a string buffer. The only control
+// sequences written are the fixed ones in this file (cursor up, erase to end of screen).
+import { emitKeypressEvents } from "node:readline";
+import { dim, terracottaBold } from "./theme.js";
+                                        
+
+                                                                                                             
+                                                                               
+// Something that delivers key presses and can be listened to exclusively: subscribe returns the
+// function that gives the keyboard back.
+                                                                                         
+                                                    
+
+const ESC = "\x1b";
+
+// A KeySource over a raw stdin stream (used where no PromptFrame owns the keyboard, and in tests
+// that drive a PassThrough).
+export function streamKeys(stdin                                                                                    )            {
+  emitKeypressEvents(stdin);
+  return {
+    subscribe(fn) {
+      const was = (stdin                       ).isRaw;
+      stdin.setRawMode?.(true);
+      stdin.on("keypress", fn);
+      stdin.resume();
+      return () => {
+        stdin.off("keypress", fn);
+        if (!was) { stdin.setRawMode?.(false); stdin.pause(); }
+      };
+    },
+  };
+}
+
+                                                                     
+                           
+                  
+               
+                                                 
+                    
+                 
+                                              
+                                                       
+  
+
+const oneLine = (s        ) => s.replace(/[\u0000-\u001f\u007f-\u009f]/g, " ").replace(/\s+/g, " ").trim();
+
+// Draws the list and returns the number of rows written. Text comes from our own tables or from
+// a provider's model list, so it is cut to one plain line first.
+export function renderPick   (items                        , active        , o                                                )           {
+  const s = o.style ?? { color: false, depth: 8 };
+  const pointer = o.unicode === false ? ">" : "❯";
+  const max = Math.max(1, o.max ?? 10);
+  const start = Math.max(0, Math.min(active - max + 1, items.length - max));
+  return items.slice(start, start + max).map((it, i) => {
+    const on = start + i === active;
+    const label = oneLine(it.label);
+    const hint = it.hint ? " " + dim(s, oneLine(it.hint)) : "";
+    return on ? `${terracottaBold(s, `${pointer} ${label}`)}${hint}` : `  ${label}${hint}`;
+  });
+}
+
+// Up/Down (or k/j) move, Enter confirms, Esc or Ctrl+C cancels. Resolves to the chosen value, or
+// undefined when cancelled. The list is erased on the way out so the transcript stays clean.
+export function pickOne   (items                        , o             )                         {
+  if (items.length === 0) return Promise.resolve(undefined);
+  return new Promise((resolve) => {
+    let active = Math.min(Math.max(0, o.initial ?? 0), items.length - 1);
+    let rows = 0;
+    const s = o.style ?? { color: false, depth: 8 };
+    const header = o.title ? [dim(s, oneLine(o.title) + (o.unicode === false ? " (up/down, enter, esc)" : " (↑↓ move, enter select, esc cancel)"))] : [];
+    const draw = () => {
+      const lines = [...header, ...renderPick(items, active, o)];
+      let out = rows > 0 ? `\r${ESC}[${rows}A${ESC}[J` : "";
+      out += lines.join("\n") + "\n";
+      rows = lines.length;
+      o.out.write(out);
+    };
+    const finish = (v               ) => {
+      off();
+      o.out.write(`\r${ESC}[${rows}A${ESC}[J`);
+      resolve(v);
+    };
+    const off = o.keys.subscribe((str, key) => {
+      const name = key?.name;
+      const seq = key?.sequence ?? str ?? "";
+      if (name === "up" || (name === undefined && seq === "k")) active = (active - 1 + items.length) % items.length;
+      else if (name === "down" || (name === undefined && seq === "j") || name === "tab") active = (active + 1) % items.length;
+      else if (name === "return" || name === "enter") { finish((items[active]               ).value); return; }
+      else if (name === "escape" || (key?.ctrl && name === "c") || seq === "\x03") { finish(undefined); return; }
+      else return;
+      draw();
+    });
+    draw();
+  });
+}
+
+                                                                               
+
+// A secret read one key at a time; each character shows as a bullet and nothing typed is echoed.
+// Pasted text arrives as characters and is accepted; Enter ends it, Esc or Ctrl+C cancels
+// (undefined). Backspace removes one character and one bullet.
+export function readMasked(prompt        , o             )                              {
+  const bullet = o.unicode === false ? "*" : "•";
+  return new Promise((resolve) => {
+    let value = "";
+    const finish = (v                    ) => {
+      off();
+      o.out.write("\n");
+      resolve(v);
+    };
+    o.out.write(prompt);
+    const off = o.keys.subscribe((str, key) => {
+      const name = key?.name;
+      const seq = key?.sequence ?? str ?? "";
+      if (name === "return" || name === "enter" || seq === "\r" || seq === "\n") { finish(value.trim()); return; }
+      if (name === "escape" || (key?.ctrl && name === "c") || seq === "\x03") { finish(undefined); return; }
+      if (name === "backspace" || seq === "\x7f" || seq === "\b") {
+        if (value.length > 0) { value = Array.from(value).slice(0, -1).join(""); o.out.write("\b \b"); }
+        return;
+      }
+      if (key?.ctrl || key?.meta) return;
+      // Printable text only (a paste may carry several characters; control characters are dropped).
+      const text = Array.from(seq).filter((ch) => ch >= " " && ch !== "\x7f" && !/[\u0080-\u009f]/.test(ch)).join("");
+      if (!text) return;
+      value += text;
+      o.out.write(bullet.repeat(Array.from(text).length));
+    }, { paste: true });
+  });
+}

package/dist/statusbar.js

@@ -26,22 +26,29 @@ export function formatRate(tps                    )         {
 }
 
 // Fits `width` columns by dropping segments from the least important end; the tier always stays.
+// Unknown values (routing "?", no TTFT or rate yet) are left out, never shown as "?" or "-".
 export function formatStatus(p             , width         )         {
   const tier = p.tier.display;
   const effort = p.effort === "default" ? "" : `effort ${p.effort}`;
-  const full = [tier, effort, p.routing, `TTFT ${formatTtft(p.ttftMs)}`, formatRate(p.tokPerSec), `${groupDigits(p.tokens)} tokens`];
+  const route = p.routing && p.routing !== "?" ? p.routing : "";
+  const ttft = formatTtft(p.ttftMs);
+  const t = ttft === "-" ? "" : `TTFT ${ttft}`;
+  const r = formatRate(p.tokPerSec);
+  const rate = r === "-" ? "" : r;
+  const toks = `${groupDigits(p.tokens)} tokens`;
+  const short = `${groupDigits(p.tokens)} tok`;
   const variants = [
-    full,
-    [tier, p.routing, `TTFT ${formatTtft(p.ttftMs)}`, formatRate(p.tokPerSec), `${groupDigits(p.tokens)} tokens`],
-    [tier, p.routing, formatRate(p.tokPerSec), `${groupDigits(p.tokens)} tok`],
-    [tier, p.routing, `${groupDigits(p.tokens)} tok`],
-    [tier, p.routing],
+    [tier, effort, route, t, rate, toks],
+    [tier, route, t, rate, toks],
+    [tier, route, rate, short],
+    [tier, route, short],
+    [tier, route],
   ];
   const join = (parts          ) => parts.filter((x) => x !== "").join(" | ");
-  if (width === undefined) return join(full);
+  if (width === undefined) return join(variants[0]            );
   for (const v of variants) {
-    const t = join(v);
-    if (t.length <= width) return t;
+    const s = join(v);
+    if (s.length <= width) return s;
   }
   const last = join(variants[variants.length - 1]            );
   return width > 1 ? last.slice(0, width - 1) + "…" : last.slice(0, width);

package/dist/theme.js

@@ -1,7 +1,8 @@
 // The Synqa palette and every colour escape the CLI emits. This file is the only place that builds
 // an escape sequence for colour; text from the model or from tools never reaches it as a code.
-// 24-bit colour when the terminal says it has it (COLORTERM=truecolor|24bit), otherwise the nearest
-// xterm-256 index. NO_COLOR, a non-TTY or TERM=dumb turn all of it off.
+// 24-bit colour only when the terminal is known to draw it (COLORTERM=truecolor|24bit, or a
+// TERM_PROGRAM known for it); macOS Terminal.app and anything unknown get xterm-256 colours, which
+// every modern terminal draws. NO_COLOR, a non-TTY or TERM=dumb turn all of it off.
 
                                                     
 
@@ -12,8 +13,11 @@ export const SAGE      = [0x4a, 0x7c, 0x59]; // #4a7c59 sage: balance highlights
 
                                 
 
-// depth is optional so a bare { color: true } keeps meaning 24-bit.
-                                                           
+// depth is optional; absent means 256 colours, the safe choice (Terminal.app has no 24-bit colour).
+// bg is the terminal background when the environment says so (COLORFGBG); bone text is used only
+// on a known dark background, plain bold otherwise, so names read on light and dark themes.
+                                          
+                                                                            
 
 export function colorEnabled(env                                    , isTTY         )          {
   if (env.NO_COLOR !== undefined && env.NO_COLOR !== "") return false;
@@ -21,9 +25,30 @@ export function colorEnabled(env                                    , isTTY
   return isTTY;
 }
 
+// Terminals that draw 24-bit colour, by TERM_PROGRAM (compared lower case).
+const TRUECOLOR_PROGRAMS = new Set(["iterm.app", "wezterm", "vscode", "ghostty", "hyper", "tabby", "warpterminal", "rio", "kitty", "alacritty", "contour", "zed"]);
+
 export function colorDepth(env                                    )             {
+  const program = (env.TERM_PROGRAM ?? "").toLowerCase();
+  // Terminal.app before macOS 26 misdraws 24-bit escapes, and a COLORTERM copied from another
+  // terminal's profile (or passed through ssh or tmux) must not switch them on there.
+  if (program === "apple_terminal") return 8;
   const c = (env.COLORTERM ?? "").toLowerCase();
-  return c === "truecolor" || c === "24bit" ? 24 : 8;
+  if (c === "truecolor" || c === "24bit") return 24;
+  if (TRUECOLOR_PROGRAMS.has(program)) return 24;
+  const term = (env.TERM ?? "").toLowerCase();
+  if (/(^|-)(kitty|alacritty|direct|truecolor|ghostty|wezterm)($|-)/.test(term) || term.endsWith("-direct")) return 24;
+  return 8;
+}
+
+// COLORFGBG ("15;0", or "15;default;0") names the background colour index when a terminal sets
+// it (rxvt, Konsole, iTerm2 with the option on). 0-6 and 8 are dark; 7 and 9-15 are light.
+export function detectBackground(env                                    )                         {
+  const raw = env.COLORFGBG;
+  if (!raw) return undefined;
+  const bg = Number(raw.split(";").pop());
+  if (!Number.isInteger(bg) || bg < 0 || bg > 15) return undefined;
+  return bg === 7 || bg >= 9 ? "light" : "dark";
 }
 
 const CUBE = [0, 95, 135, 175, 215, 255]         ;
@@ -53,8 +78,17 @@ export function rgbTo256(rgb     )         {
 const RESET = "\x1b[0m";
 
 // The SGR parameters that select `rgb` as the foreground.
+// Hand-picked 256-colour stand-ins where the nearest match loses the brand: the nearest index for
+// terracotta (167) is a pink salmon; 166 (#d75f00) keeps the burnt orange and reads on light and
+// dark backgrounds.
+const TUNED_256 = new Map                ([[TERRACOTTA.join(","), 166]]);
+
+export function to256(rgb     )         {
+  return TUNED_256.get(rgb.join(",")) ?? rgbTo256(rgb);
+}
+
 export function fgParams(depth                        , rgb     )         {
-  return depth === 8 ? `38;5;${rgbTo256(rgb)}` : `38;2;${rgb[0]};${rgb[1]};${rgb[2]}`;
+  return depth === 24 ? `38;2;${rgb[0]};${rgb[1]};${rgb[2]}` : `38;5;${to256(rgb)}`;
 }
 
 function paint(s       , params        , text        )         {
@@ -65,8 +99,14 @@ export function terracotta(s       , text        )         {
   return paint(s, fgParams(s.depth, TERRACOTTA), text);
 }
 
+// Bone on a known dark background; plain bold (the terminal's own text colour) otherwise, because
+// bone is nearly invisible on a light background.
 export function boneBold(s       , text        )         {
-  return paint(s, `1;${fgParams(s.depth, BONE)}`, text);
+  return paint(s, s.bg === "dark" ? `1;${fgParams(s.depth, BONE)}` : "1", text);
+}
+
+export function terracottaBold(s       , text        )         {
+  return paint(s, `1;${fgParams(s.depth, TERRACOTTA)}`, text);
 }
 
 export function stone(s       , text        )         {

package/dist/tiers.js

@@ -9,7 +9,7 @@ export const TIERS                  = [
 export const DEFAULT_TIER = "blink";
 
 // Reasoning effort the user can pick. "default" sends no reasoning_effort at all.
-export const EFFORTS = ["default", "low", "medium"]         ;
+export const EFFORTS = ["default", "low", "medium", "high"]         ;
                                               
 
 export function findEffort(name        )                     {