@saidulbadhon/jssm-cli 1.5.5 → 1.6.2

package/dist/index.js

@@ -304,7 +304,9 @@ async function login(host, email, password) {
     });
     return { success: true };
   } catch (error) {
-    return { success: false, error: error.message || "Network error" };
+    const isConnectionError = error.code === "ECONNREFUSED" || error.code === "ENOTFOUND" || error.code === "ETIMEDOUT" || error.code === "ECONNRESET" || error.cause?.code === "ECONNREFUSED" || error.cause?.code === "ENOTFOUND" || error.cause?.code === "ETIMEDOUT" || error.cause?.code === "ECONNRESET" || error.message?.includes("fetch failed") || error.message?.includes("ECONNREFUSED") || error.message?.includes("ENOTFOUND");
+    const errorMessage = isConnectionError ? "Unable to connect. Is the computer able to access the url?" : error.message || "Network error";
+    return { success: false, error: errorMessage, isConnectionError };
   }
 }
 async function register(host, email, password, name) {
@@ -329,7 +331,9 @@ async function register(host, email, password, name) {
     });
     return { success: true };
   } catch (error) {
-    return { success: false, error: error.message || "Network error" };
+    const isConnectionError = error.code === "ECONNREFUSED" || error.code === "ENOTFOUND" || error.code === "ETIMEDOUT" || error.code === "ECONNRESET" || error.cause?.code === "ECONNREFUSED" || error.cause?.code === "ENOTFOUND" || error.cause?.code === "ETIMEDOUT" || error.cause?.code === "ECONNRESET" || error.message?.includes("fetch failed") || error.message?.includes("ECONNREFUSED") || error.message?.includes("ENOTFOUND");
+    const errorMessage = isConnectionError ? "Unable to connect. Is the computer able to access the url?" : error.message || "Network error";
+    return { success: false, error: errorMessage, isConnectionError };
   }
 }
 var AUTH_DIR, AUTH_FILE;
@@ -341,176 +345,1723 @@ var init_auth = __esm({
   }
 });
 
-// node_modules/@inquirer/core/dist/lib/key.js
-var isUpKey = (key, keybindings = []) => (
-  // The up key
-  key.name === "up" || // Vim keybinding: hjkl keys map to left/down/up/right
-  keybindings.includes("vim") && key.name === "k" || // Emacs keybinding: Ctrl+P means "previous" in Emacs navigation conventions
-  keybindings.includes("emacs") && key.ctrl && key.name === "p"
-);
-var isDownKey = (key, keybindings = []) => (
-  // The down key
-  key.name === "down" || // Vim keybinding: hjkl keys map to left/down/up/right
-  keybindings.includes("vim") && key.name === "j" || // Emacs keybinding: Ctrl+N means "next" in Emacs navigation conventions
-  keybindings.includes("emacs") && key.ctrl && key.name === "n"
-);
-var isSpaceKey = (key) => key.name === "space";
-var isBackspaceKey = (key) => key.name === "backspace";
-var isTabKey = (key) => key.name === "tab";
-var isNumberKey = (key) => "1234567890".includes(key.name);
-var isEnterKey = (key) => key.name === "enter" || key.name === "return";
-
-// node_modules/@inquirer/core/dist/lib/errors.js
-var AbortPromptError = class extends Error {
-  name = "AbortPromptError";
-  message = "Prompt was aborted";
-  constructor(options) {
-    super();
-    this.cause = options?.cause;
+// ../node_modules/color-name/index.js
+var require_color_name = __commonJS({
+  "../node_modules/color-name/index.js"(exports, module) {
+    "use strict";
+    module.exports = {
+      "aliceblue": [240, 248, 255],
+      "antiquewhite": [250, 235, 215],
+      "aqua": [0, 255, 255],
+      "aquamarine": [127, 255, 212],
+      "azure": [240, 255, 255],
+      "beige": [245, 245, 220],
+      "bisque": [255, 228, 196],
+      "black": [0, 0, 0],
+      "blanchedalmond": [255, 235, 205],
+      "blue": [0, 0, 255],
+      "blueviolet": [138, 43, 226],
+      "brown": [165, 42, 42],
+      "burlywood": [222, 184, 135],
+      "cadetblue": [95, 158, 160],
+      "chartreuse": [127, 255, 0],
+      "chocolate": [210, 105, 30],
+      "coral": [255, 127, 80],
+      "cornflowerblue": [100, 149, 237],
+      "cornsilk": [255, 248, 220],
+      "crimson": [220, 20, 60],
+      "cyan": [0, 255, 255],
+      "darkblue": [0, 0, 139],
+      "darkcyan": [0, 139, 139],
+      "darkgoldenrod": [184, 134, 11],
+      "darkgray": [169, 169, 169],
+      "darkgreen": [0, 100, 0],
+      "darkgrey": [169, 169, 169],
+      "darkkhaki": [189, 183, 107],
+      "darkmagenta": [139, 0, 139],
+      "darkolivegreen": [85, 107, 47],
+      "darkorange": [255, 140, 0],
+      "darkorchid": [153, 50, 204],
+      "darkred": [139, 0, 0],
+      "darksalmon": [233, 150, 122],
+      "darkseagreen": [143, 188, 143],
+      "darkslateblue": [72, 61, 139],
+      "darkslategray": [47, 79, 79],
+      "darkslategrey": [47, 79, 79],
+      "darkturquoise": [0, 206, 209],
+      "darkviolet": [148, 0, 211],
+      "deeppink": [255, 20, 147],
+      "deepskyblue": [0, 191, 255],
+      "dimgray": [105, 105, 105],
+      "dimgrey": [105, 105, 105],
+      "dodgerblue": [30, 144, 255],
+      "firebrick": [178, 34, 34],
+      "floralwhite": [255, 250, 240],
+      "forestgreen": [34, 139, 34],
+      "fuchsia": [255, 0, 255],
+      "gainsboro": [220, 220, 220],
+      "ghostwhite": [248, 248, 255],
+      "gold": [255, 215, 0],
+      "goldenrod": [218, 165, 32],
+      "gray": [128, 128, 128],
+      "green": [0, 128, 0],
+      "greenyellow": [173, 255, 47],
+      "grey": [128, 128, 128],
+      "honeydew": [240, 255, 240],
+      "hotpink": [255, 105, 180],
+      "indianred": [205, 92, 92],
+      "indigo": [75, 0, 130],
+      "ivory": [255, 255, 240],
+      "khaki": [240, 230, 140],
+      "lavender": [230, 230, 250],
+      "lavenderblush": [255, 240, 245],
+      "lawngreen": [124, 252, 0],
+      "lemonchiffon": [255, 250, 205],
+      "lightblue": [173, 216, 230],
+      "lightcoral": [240, 128, 128],
+      "lightcyan": [224, 255, 255],
+      "lightgoldenrodyellow": [250, 250, 210],
+      "lightgray": [211, 211, 211],
+      "lightgreen": [144, 238, 144],
+      "lightgrey": [211, 211, 211],
+      "lightpink": [255, 182, 193],
+      "lightsalmon": [255, 160, 122],
+      "lightseagreen": [32, 178, 170],
+      "lightskyblue": [135, 206, 250],
+      "lightslategray": [119, 136, 153],
+      "lightslategrey": [119, 136, 153],
+      "lightsteelblue": [176, 196, 222],
+      "lightyellow": [255, 255, 224],
+      "lime": [0, 255, 0],
+      "limegreen": [50, 205, 50],
+      "linen": [250, 240, 230],
+      "magenta": [255, 0, 255],
+      "maroon": [128, 0, 0],
+      "mediumaquamarine": [102, 205, 170],
+      "mediumblue": [0, 0, 205],
+      "mediumorchid": [186, 85, 211],
+      "mediumpurple": [147, 112, 219],
+      "mediumseagreen": [60, 179, 113],
+      "mediumslateblue": [123, 104, 238],
+      "mediumspringgreen": [0, 250, 154],
+      "mediumturquoise": [72, 209, 204],
+      "mediumvioletred": [199, 21, 133],
+      "midnightblue": [25, 25, 112],
+      "mintcream": [245, 255, 250],
+      "mistyrose": [255, 228, 225],
+      "moccasin": [255, 228, 181],
+      "navajowhite": [255, 222, 173],
+      "navy": [0, 0, 128],
+      "oldlace": [253, 245, 230],
+      "olive": [128, 128, 0],
+      "olivedrab": [107, 142, 35],
+      "orange": [255, 165, 0],
+      "orangered": [255, 69, 0],
+      "orchid": [218, 112, 214],
+      "palegoldenrod": [238, 232, 170],
+      "palegreen": [152, 251, 152],
+      "paleturquoise": [175, 238, 238],
+      "palevioletred": [219, 112, 147],
+      "papayawhip": [255, 239, 213],
+      "peachpuff": [255, 218, 185],
+      "peru": [205, 133, 63],
+      "pink": [255, 192, 203],
+      "plum": [221, 160, 221],
+      "powderblue": [176, 224, 230],
+      "purple": [128, 0, 128],
+      "rebeccapurple": [102, 51, 153],
+      "red": [255, 0, 0],
+      "rosybrown": [188, 143, 143],
+      "royalblue": [65, 105, 225],
+      "saddlebrown": [139, 69, 19],
+      "salmon": [250, 128, 114],
+      "sandybrown": [244, 164, 96],
+      "seagreen": [46, 139, 87],
+      "seashell": [255, 245, 238],
+      "sienna": [160, 82, 45],
+      "silver": [192, 192, 192],
+      "skyblue": [135, 206, 235],
+      "slateblue": [106, 90, 205],
+      "slategray": [112, 128, 144],
+      "slategrey": [112, 128, 144],
+      "snow": [255, 250, 250],
+      "springgreen": [0, 255, 127],
+      "steelblue": [70, 130, 180],
+      "tan": [210, 180, 140],
+      "teal": [0, 128, 128],
+      "thistle": [216, 191, 216],
+      "tomato": [255, 99, 71],
+      "turquoise": [64, 224, 208],
+      "violet": [238, 130, 238],
+      "wheat": [245, 222, 179],
+      "white": [255, 255, 255],
+      "whitesmoke": [245, 245, 245],
+      "yellow": [255, 255, 0],
+      "yellowgreen": [154, 205, 50]
+    };
   }
-};
-var CancelPromptError = class extends Error {
-  name = "CancelPromptError";
-  message = "Prompt was canceled";
-};
-var ExitPromptError = class extends Error {
-  name = "ExitPromptError";
-};
-var HookError = class extends Error {
-  name = "HookError";
-};
-var ValidationError = class extends Error {
-  name = "ValidationError";
-};
-
-// node_modules/@inquirer/core/dist/lib/use-state.js
-import { AsyncResource as AsyncResource2 } from "node:async_hooks";
+});
 
-// node_modules/@inquirer/core/dist/lib/hook-engine.js
-import { AsyncLocalStorage, AsyncResource } from "node:async_hooks";
-var hookStorage = new AsyncLocalStorage();
-function createStore(rl) {
-  const store = {
-    rl,
-    hooks: [],
-    hooksCleanup: [],
-    hooksEffect: [],
-    index: 0,
-    handleChange() {
+// ../node_modules/color-convert/conversions.js
+var require_conversions = __commonJS({
+  "../node_modules/color-convert/conversions.js"(exports, module) {
+    var cssKeywords = require_color_name();
+    var reverseKeywords = {};
+    for (const key of Object.keys(cssKeywords)) {
+      reverseKeywords[cssKeywords[key]] = key;
     }
-  };
-  return store;
-}
-function withHooks(rl, cb) {
-  const store = createStore(rl);
-  return hookStorage.run(store, () => {
-    function cycle(render) {
-      store.handleChange = () => {
-        store.index = 0;
-        render();
-      };
-      store.handleChange();
+    var convert = {
+      rgb: { channels: 3, labels: "rgb" },
+      hsl: { channels: 3, labels: "hsl" },
+      hsv: { channels: 3, labels: "hsv" },
+      hwb: { channels: 3, labels: "hwb" },
+      cmyk: { channels: 4, labels: "cmyk" },
+      xyz: { channels: 3, labels: "xyz" },
+      lab: { channels: 3, labels: "lab" },
+      lch: { channels: 3, labels: "lch" },
+      hex: { channels: 1, labels: ["hex"] },
+      keyword: { channels: 1, labels: ["keyword"] },
+      ansi16: { channels: 1, labels: ["ansi16"] },
+      ansi256: { channels: 1, labels: ["ansi256"] },
+      hcg: { channels: 3, labels: ["h", "c", "g"] },
+      apple: { channels: 3, labels: ["r16", "g16", "b16"] },
+      gray: { channels: 1, labels: ["gray"] }
+    };
+    module.exports = convert;
+    for (const model of Object.keys(convert)) {
+      if (!("channels" in convert[model])) {
+        throw new Error("missing channels property: " + model);
+      }
+      if (!("labels" in convert[model])) {
+        throw new Error("missing channel labels property: " + model);
+      }
+      if (convert[model].labels.length !== convert[model].channels) {
+        throw new Error("channel and label counts mismatch: " + model);
+      }
+      const { channels, labels } = convert[model];
+      delete convert[model].channels;
+      delete convert[model].labels;
+      Object.defineProperty(convert[model], "channels", { value: channels });
+      Object.defineProperty(convert[model], "labels", { value: labels });
     }
-    return cb(cycle);
-  });
-}
-function getStore() {
-  const store = hookStorage.getStore();
-  if (!store) {
-    throw new HookError("[Inquirer] Hook functions can only be called from within a prompt");
-  }
-  return store;
-}
-function readline() {
-  return getStore().rl;
-}
-function withUpdates(fn) {
-  const wrapped = (...args2) => {
-    const store = getStore();
-    let shouldUpdate = false;
-    const oldHandleChange = store.handleChange;
-    store.handleChange = () => {
-      shouldUpdate = true;
+    convert.rgb.hsl = function(rgb) {
+      const r = rgb[0] / 255;
+      const g = rgb[1] / 255;
+      const b = rgb[2] / 255;
+      const min = Math.min(r, g, b);
+      const max = Math.max(r, g, b);
+      const delta = max - min;
+      let h;
+      let s;
+      if (max === min) {
+        h = 0;
+      } else if (r === max) {
+        h = (g - b) / delta;
+      } else if (g === max) {
+        h = 2 + (b - r) / delta;
+      } else if (b === max) {
+        h = 4 + (r - g) / delta;
+      }
+      h = Math.min(h * 60, 360);
+      if (h < 0) {
+        h += 360;
+      }
+      const l = (min + max) / 2;
+      if (max === min) {
+        s = 0;
+      } else if (l <= 0.5) {
+        s = delta / (max + min);
+      } else {
+        s = delta / (2 - max - min);
+      }
+      return [h, s * 100, l * 100];
     };
-    const returnValue = fn(...args2);
-    if (shouldUpdate) {
-      oldHandleChange();
+    convert.rgb.hsv = function(rgb) {
+      let rdif;
+      let gdif;
+      let bdif;
+      let h;
+      let s;
+      const r = rgb[0] / 255;
+      const g = rgb[1] / 255;
+      const b = rgb[2] / 255;
+      const v = Math.max(r, g, b);
+      const diff = v - Math.min(r, g, b);
+      const diffc = function(c) {
+        return (v - c) / 6 / diff + 1 / 2;
+      };
+      if (diff === 0) {
+        h = 0;
+        s = 0;
+      } else {
+        s = diff / v;
+        rdif = diffc(r);
+        gdif = diffc(g);
+        bdif = diffc(b);
+        if (r === v) {
+          h = bdif - gdif;
+        } else if (g === v) {
+          h = 1 / 3 + rdif - bdif;
+        } else if (b === v) {
+          h = 2 / 3 + gdif - rdif;
+        }
+        if (h < 0) {
+          h += 1;
+        } else if (h > 1) {
+          h -= 1;
+        }
+      }
+      return [
+        h * 360,
+        s * 100,
+        v * 100
+      ];
+    };
+    convert.rgb.hwb = function(rgb) {
+      const r = rgb[0];
+      const g = rgb[1];
+      let b = rgb[2];
+      const h = convert.rgb.hsl(rgb)[0];
+      const w = 1 / 255 * Math.min(r, Math.min(g, b));
+      b = 1 - 1 / 255 * Math.max(r, Math.max(g, b));
+      return [h, w * 100, b * 100];
+    };
+    convert.rgb.cmyk = function(rgb) {
+      const r = rgb[0] / 255;
+      const g = rgb[1] / 255;
+      const b = rgb[2] / 255;
+      const k = Math.min(1 - r, 1 - g, 1 - b);
+      const c = (1 - r - k) / (1 - k) || 0;
+      const m = (1 - g - k) / (1 - k) || 0;
+      const y = (1 - b - k) / (1 - k) || 0;
+      return [c * 100, m * 100, y * 100, k * 100];
+    };
+    function comparativeDistance(x, y) {
+      return (x[0] - y[0]) ** 2 + (x[1] - y[1]) ** 2 + (x[2] - y[2]) ** 2;
     }
-    store.handleChange = oldHandleChange;
-    return returnValue;
-  };
-  return AsyncResource.bind(wrapped);
-}
-function withPointer(cb) {
-  const store = getStore();
-  const { index } = store;
-  const pointer = {
-    get() {
-      return store.hooks[index];
-    },
-    set(value) {
-      store.hooks[index] = value;
-    },
-    initialized: index in store.hooks
-  };
-  const returnValue = cb(pointer);
-  store.index++;
-  return returnValue;
-}
-function handleChange() {
-  getStore().handleChange();
-}
-var effectScheduler = {
-  queue(cb) {
-    const store = getStore();
-    const { index } = store;
-    store.hooksEffect.push(() => {
-      store.hooksCleanup[index]?.();
-      const cleanFn = cb(readline());
-      if (cleanFn != null && typeof cleanFn !== "function") {
-        throw new ValidationError("useEffect return value must be a cleanup function or nothing.");
+    convert.rgb.keyword = function(rgb) {
+      const reversed = reverseKeywords[rgb];
+      if (reversed) {
+        return reversed;
       }
-      store.hooksCleanup[index] = cleanFn;
-    });
-  },
-  run() {
-    const store = getStore();
-    withUpdates(() => {
-      store.hooksEffect.forEach((effect) => {
-        effect();
-      });
-      store.hooksEffect.length = 0;
-    })();
-  },
-  clearAll() {
-    const store = getStore();
-    store.hooksCleanup.forEach((cleanFn) => {
-      cleanFn?.();
-    });
-    store.hooksEffect.length = 0;
-    store.hooksCleanup.length = 0;
+      let currentClosestDistance = Infinity;
+      let currentClosestKeyword;
+      for (const keyword of Object.keys(cssKeywords)) {
+        const value = cssKeywords[keyword];
+        const distance = comparativeDistance(rgb, value);
+        if (distance < currentClosestDistance) {
+          currentClosestDistance = distance;
+          currentClosestKeyword = keyword;
+        }
+      }
+      return currentClosestKeyword;
+    };
+    convert.keyword.rgb = function(keyword) {
+      return cssKeywords[keyword];
+    };
+    convert.rgb.xyz = function(rgb) {
+      let r = rgb[0] / 255;
+      let g = rgb[1] / 255;
+      let b = rgb[2] / 255;
+      r = r > 0.04045 ? ((r + 0.055) / 1.055) ** 2.4 : r / 12.92;
+      g = g > 0.04045 ? ((g + 0.055) / 1.055) ** 2.4 : g / 12.92;
+      b = b > 0.04045 ? ((b + 0.055) / 1.055) ** 2.4 : b / 12.92;
+      const x = r * 0.4124 + g * 0.3576 + b * 0.1805;
+      const y = r * 0.2126 + g * 0.7152 + b * 0.0722;
+      const z = r * 0.0193 + g * 0.1192 + b * 0.9505;
+      return [x * 100, y * 100, z * 100];
+    };
+    convert.rgb.lab = function(rgb) {
+      const xyz = convert.rgb.xyz(rgb);
+      let x = xyz[0];
+      let y = xyz[1];
+      let z = xyz[2];
+      x /= 95.047;
+      y /= 100;
+      z /= 108.883;
+      x = x > 8856e-6 ? x ** (1 / 3) : 7.787 * x + 16 / 116;
+      y = y > 8856e-6 ? y ** (1 / 3) : 7.787 * y + 16 / 116;
+      z = z > 8856e-6 ? z ** (1 / 3) : 7.787 * z + 16 / 116;
+      const l = 116 * y - 16;
+      const a = 500 * (x - y);
+      const b = 200 * (y - z);
+      return [l, a, b];
+    };
+    convert.hsl.rgb = function(hsl) {
+      const h = hsl[0] / 360;
+      const s = hsl[1] / 100;
+      const l = hsl[2] / 100;
+      let t2;
+      let t3;
+      let val;
+      if (s === 0) {
+        val = l * 255;
+        return [val, val, val];
+      }
+      if (l < 0.5) {
+        t2 = l * (1 + s);
+      } else {
+        t2 = l + s - l * s;
+      }
+      const t1 = 2 * l - t2;
+      const rgb = [0, 0, 0];
+      for (let i = 0; i < 3; i++) {
+        t3 = h + 1 / 3 * -(i - 1);
+        if (t3 < 0) {
+          t3++;
+        }
+        if (t3 > 1) {
+          t3--;
+        }
+        if (6 * t3 < 1) {
+          val = t1 + (t2 - t1) * 6 * t3;
+        } else if (2 * t3 < 1) {
+          val = t2;
+        } else if (3 * t3 < 2) {
+          val = t1 + (t2 - t1) * (2 / 3 - t3) * 6;
+        } else {
+          val = t1;
+        }
+        rgb[i] = val * 255;
+      }
+      return rgb;
+    };
+    convert.hsl.hsv = function(hsl) {
+      const h = hsl[0];
+      let s = hsl[1] / 100;
+      let l = hsl[2] / 100;
+      let smin = s;
+      const lmin = Math.max(l, 0.01);
+      l *= 2;
+      s *= l <= 1 ? l : 2 - l;
+      smin *= lmin <= 1 ? lmin : 2 - lmin;
+      const v = (l + s) / 2;
+      const sv = l === 0 ? 2 * smin / (lmin + smin) : 2 * s / (l + s);
+      return [h, sv * 100, v * 100];
+    };
+    convert.hsv.rgb = function(hsv) {
+      const h = hsv[0] / 60;
+      const s = hsv[1] / 100;
+      let v = hsv[2] / 100;
+      const hi = Math.floor(h) % 6;
+      const f = h - Math.floor(h);
+      const p = 255 * v * (1 - s);
+      const q = 255 * v * (1 - s * f);
+      const t = 255 * v * (1 - s * (1 - f));
+      v *= 255;
+      switch (hi) {
+        case 0:
+          return [v, t, p];
+        case 1:
+          return [q, v, p];
+        case 2:
+          return [p, v, t];
+        case 3:
+          return [p, q, v];
+        case 4:
+          return [t, p, v];
+        case 5:
+          return [v, p, q];
+      }
+    };
+    convert.hsv.hsl = function(hsv) {
+      const h = hsv[0];
+      const s = hsv[1] / 100;
+      const v = hsv[2] / 100;
+      const vmin = Math.max(v, 0.01);
+      let sl;
+      let l;
+      l = (2 - s) * v;
+      const lmin = (2 - s) * vmin;
+      sl = s * vmin;
+      sl /= lmin <= 1 ? lmin : 2 - lmin;
+      sl = sl || 0;
+      l /= 2;
+      return [h, sl * 100, l * 100];
+    };
+    convert.hwb.rgb = function(hwb) {
+      const h = hwb[0] / 360;
+      let wh = hwb[1] / 100;
+      let bl = hwb[2] / 100;
+      const ratio = wh + bl;
+      let f;
+      if (ratio > 1) {
+        wh /= ratio;
+        bl /= ratio;
+      }
+      const i = Math.floor(6 * h);
+      const v = 1 - bl;
+      f = 6 * h - i;
+      if ((i & 1) !== 0) {
+        f = 1 - f;
+      }
+      const n = wh + f * (v - wh);
+      let r;
+      let g;
+      let b;
+      switch (i) {
+        default:
+        case 6:
+        case 0:
+          r = v;
+          g = n;
+          b = wh;
+          break;
+        case 1:
+          r = n;
+          g = v;
+          b = wh;
+          break;
+        case 2:
+          r = wh;
+          g = v;
+          b = n;
+          break;
+        case 3:
+          r = wh;
+          g = n;
+          b = v;
+          break;
+        case 4:
+          r = n;
+          g = wh;
+          b = v;
+          break;
+        case 5:
+          r = v;
+          g = wh;
+          b = n;
+          break;
+      }
+      return [r * 255, g * 255, b * 255];
+    };
+    convert.cmyk.rgb = function(cmyk) {
+      const c = cmyk[0] / 100;
+      const m = cmyk[1] / 100;
+      const y = cmyk[2] / 100;
+      const k = cmyk[3] / 100;
+      const r = 1 - Math.min(1, c * (1 - k) + k);
+      const g = 1 - Math.min(1, m * (1 - k) + k);
+      const b = 1 - Math.min(1, y * (1 - k) + k);
+      return [r * 255, g * 255, b * 255];
+    };
+    convert.xyz.rgb = function(xyz) {
+      const x = xyz[0] / 100;
+      const y = xyz[1] / 100;
+      const z = xyz[2] / 100;
+      let r;
+      let g;
+      let b;
+      r = x * 3.2406 + y * -1.5372 + z * -0.4986;
+      g = x * -0.9689 + y * 1.8758 + z * 0.0415;
+      b = x * 0.0557 + y * -0.204 + z * 1.057;
+      r = r > 31308e-7 ? 1.055 * r ** (1 / 2.4) - 0.055 : r * 12.92;
+      g = g > 31308e-7 ? 1.055 * g ** (1 / 2.4) - 0.055 : g * 12.92;
+      b = b > 31308e-7 ? 1.055 * b ** (1 / 2.4) - 0.055 : b * 12.92;
+      r = Math.min(Math.max(0, r), 1);
+      g = Math.min(Math.max(0, g), 1);
+      b = Math.min(Math.max(0, b), 1);
+      return [r * 255, g * 255, b * 255];
+    };
+    convert.xyz.lab = function(xyz) {
+      let x = xyz[0];
+      let y = xyz[1];
+      let z = xyz[2];
+      x /= 95.047;
+      y /= 100;
+      z /= 108.883;
+      x = x > 8856e-6 ? x ** (1 / 3) : 7.787 * x + 16 / 116;
+      y = y > 8856e-6 ? y ** (1 / 3) : 7.787 * y + 16 / 116;
+      z = z > 8856e-6 ? z ** (1 / 3) : 7.787 * z + 16 / 116;
+      const l = 116 * y - 16;
+      const a = 500 * (x - y);
+      const b = 200 * (y - z);
+      return [l, a, b];
+    };
+    convert.lab.xyz = function(lab) {
+      const l = lab[0];
+      const a = lab[1];
+      const b = lab[2];
+      let x;
+      let y;
+      let z;
+      y = (l + 16) / 116;
+      x = a / 500 + y;
+      z = y - b / 200;
+      const y2 = y ** 3;
+      const x2 = x ** 3;
+      const z2 = z ** 3;
+      y = y2 > 8856e-6 ? y2 : (y - 16 / 116) / 7.787;
+      x = x2 > 8856e-6 ? x2 : (x - 16 / 116) / 7.787;
+      z = z2 > 8856e-6 ? z2 : (z - 16 / 116) / 7.787;
+      x *= 95.047;
+      y *= 100;
+      z *= 108.883;
+      return [x, y, z];
+    };
+    convert.lab.lch = function(lab) {
+      const l = lab[0];
+      const a = lab[1];
+      const b = lab[2];
+      let h;
+      const hr = Math.atan2(b, a);
+      h = hr * 360 / 2 / Math.PI;
+      if (h < 0) {
+        h += 360;
+      }
+      const c = Math.sqrt(a * a + b * b);
+      return [l, c, h];
+    };
+    convert.lch.lab = function(lch) {
+      const l = lch[0];
+      const c = lch[1];
+      const h = lch[2];
+      const hr = h / 360 * 2 * Math.PI;
+      const a = c * Math.cos(hr);
+      const b = c * Math.sin(hr);
+      return [l, a, b];
+    };
+    convert.rgb.ansi16 = function(args2, saturation = null) {
+      const [r, g, b] = args2;
+      let value = saturation === null ? convert.rgb.hsv(args2)[2] : saturation;
+      value = Math.round(value / 50);
+      if (value === 0) {
+        return 30;
+      }
+      let ansi = 30 + (Math.round(b / 255) << 2 | Math.round(g / 255) << 1 | Math.round(r / 255));
+      if (value === 2) {
+        ansi += 60;
+      }
+      return ansi;
+    };
+    convert.hsv.ansi16 = function(args2) {
+      return convert.rgb.ansi16(convert.hsv.rgb(args2), args2[2]);
+    };
+    convert.rgb.ansi256 = function(args2) {
+      const r = args2[0];
+      const g = args2[1];
+      const b = args2[2];
+      if (r === g && g === b) {
+        if (r < 8) {
+          return 16;
+        }
+        if (r > 248) {
+          return 231;
+        }
+        return Math.round((r - 8) / 247 * 24) + 232;
+      }
+      const ansi = 16 + 36 * Math.round(r / 255 * 5) + 6 * Math.round(g / 255 * 5) + Math.round(b / 255 * 5);
+      return ansi;
+    };
+    convert.ansi16.rgb = function(args2) {
+      let color = args2 % 10;
+      if (color === 0 || color === 7) {
+        if (args2 > 50) {
+          color += 3.5;
+        }
+        color = color / 10.5 * 255;
+        return [color, color, color];
+      }
+      const mult = (~~(args2 > 50) + 1) * 0.5;
+      const r = (color & 1) * mult * 255;
+      const g = (color >> 1 & 1) * mult * 255;
+      const b = (color >> 2 & 1) * mult * 255;
+      return [r, g, b];
+    };
+    convert.ansi256.rgb = function(args2) {
+      if (args2 >= 232) {
+        const c = (args2 - 232) * 10 + 8;
+        return [c, c, c];
+      }
+      args2 -= 16;
+      let rem;
+      const r = Math.floor(args2 / 36) / 5 * 255;
+      const g = Math.floor((rem = args2 % 36) / 6) / 5 * 255;
+      const b = rem % 6 / 5 * 255;
+      return [r, g, b];
+    };
+    convert.rgb.hex = function(args2) {
+      const integer = ((Math.round(args2[0]) & 255) << 16) + ((Math.round(args2[1]) & 255) << 8) + (Math.round(args2[2]) & 255);
+      const string = integer.toString(16).toUpperCase();
+      return "000000".substring(string.length) + string;
+    };
+    convert.hex.rgb = function(args2) {
+      const match = args2.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i);
+      if (!match) {
+        return [0, 0, 0];
+      }
+      let colorString = match[0];
+      if (match[0].length === 3) {
+        colorString = colorString.split("").map((char) => {
+          return char + char;
+        }).join("");
+      }
+      const integer = parseInt(colorString, 16);
+      const r = integer >> 16 & 255;
+      const g = integer >> 8 & 255;
+      const b = integer & 255;
+      return [r, g, b];
+    };
+    convert.rgb.hcg = function(rgb) {
+      const r = rgb[0] / 255;
+      const g = rgb[1] / 255;
+      const b = rgb[2] / 255;
+      const max = Math.max(Math.max(r, g), b);
+      const min = Math.min(Math.min(r, g), b);
+      const chroma = max - min;
+      let grayscale;
+      let hue;
+      if (chroma < 1) {
+        grayscale = min / (1 - chroma);
+      } else {
+        grayscale = 0;
+      }
+      if (chroma <= 0) {
+        hue = 0;
+      } else if (max === r) {
+        hue = (g - b) / chroma % 6;
+      } else if (max === g) {
+        hue = 2 + (b - r) / chroma;
+      } else {
+        hue = 4 + (r - g) / chroma;
+      }
+      hue /= 6;
+      hue %= 1;
+      return [hue * 360, chroma * 100, grayscale * 100];
+    };
+    convert.hsl.hcg = function(hsl) {
+      const s = hsl[1] / 100;
+      const l = hsl[2] / 100;
+      const c = l < 0.5 ? 2 * s * l : 2 * s * (1 - l);
+      let f = 0;
+      if (c < 1) {
+        f = (l - 0.5 * c) / (1 - c);
+      }
+      return [hsl[0], c * 100, f * 100];
+    };
+    convert.hsv.hcg = function(hsv) {
+      const s = hsv[1] / 100;
+      const v = hsv[2] / 100;
+      const c = s * v;
+      let f = 0;
+      if (c < 1) {
+        f = (v - c) / (1 - c);
+      }
+      return [hsv[0], c * 100, f * 100];
+    };
+    convert.hcg.rgb = function(hcg) {
+      const h = hcg[0] / 360;
+      const c = hcg[1] / 100;
+      const g = hcg[2] / 100;
+      if (c === 0) {
+        return [g * 255, g * 255, g * 255];
+      }
+      const pure = [0, 0, 0];
+      const hi = h % 1 * 6;
+      const v = hi % 1;
+      const w = 1 - v;
+      let mg = 0;
+      switch (Math.floor(hi)) {
+        case 0:
+          pure[0] = 1;
+          pure[1] = v;
+          pure[2] = 0;
+          break;
+        case 1:
+          pure[0] = w;
+          pure[1] = 1;
+          pure[2] = 0;
+          break;
+        case 2:
+          pure[0] = 0;
+          pure[1] = 1;
+          pure[2] = v;
+          break;
+        case 3:
+          pure[0] = 0;
+          pure[1] = w;
+          pure[2] = 1;
+          break;
+        case 4:
+          pure[0] = v;
+          pure[1] = 0;
+          pure[2] = 1;
+          break;
+        default:
+          pure[0] = 1;
+          pure[1] = 0;
+          pure[2] = w;
+      }
+      mg = (1 - c) * g;
+      return [
+        (c * pure[0] + mg) * 255,
+        (c * pure[1] + mg) * 255,
+        (c * pure[2] + mg) * 255
+      ];
+    };
+    convert.hcg.hsv = function(hcg) {
+      const c = hcg[1] / 100;
+      const g = hcg[2] / 100;
+      const v = c + g * (1 - c);
+      let f = 0;
+      if (v > 0) {
+        f = c / v;
+      }
+      return [hcg[0], f * 100, v * 100];
+    };
+    convert.hcg.hsl = function(hcg) {
+      const c = hcg[1] / 100;
+      const g = hcg[2] / 100;
+      const l = g * (1 - c) + 0.5 * c;
+      let s = 0;
+      if (l > 0 && l < 0.5) {
+        s = c / (2 * l);
+      } else if (l >= 0.5 && l < 1) {
+        s = c / (2 * (1 - l));
+      }
+      return [hcg[0], s * 100, l * 100];
+    };
+    convert.hcg.hwb = function(hcg) {
+      const c = hcg[1] / 100;
+      const g = hcg[2] / 100;
+      const v = c + g * (1 - c);
+      return [hcg[0], (v - c) * 100, (1 - v) * 100];
+    };
+    convert.hwb.hcg = function(hwb) {
+      const w = hwb[1] / 100;
+      const b = hwb[2] / 100;
+      const v = 1 - b;
+      const c = v - w;
+      let g = 0;
+      if (c < 1) {
+        g = (v - c) / (1 - c);
+      }
+      return [hwb[0], c * 100, g * 100];
+    };
+    convert.apple.rgb = function(apple) {
+      return [apple[0] / 65535 * 255, apple[1] / 65535 * 255, apple[2] / 65535 * 255];
+    };
+    convert.rgb.apple = function(rgb) {
+      return [rgb[0] / 255 * 65535, rgb[1] / 255 * 65535, rgb[2] / 255 * 65535];
+    };
+    convert.gray.rgb = function(args2) {
+      return [args2[0] / 100 * 255, args2[0] / 100 * 255, args2[0] / 100 * 255];
+    };
+    convert.gray.hsl = function(args2) {
+      return [0, 0, args2[0]];
+    };
+    convert.gray.hsv = convert.gray.hsl;
+    convert.gray.hwb = function(gray) {
+      return [0, 100, gray[0]];
+    };
+    convert.gray.cmyk = function(gray) {
+      return [0, 0, 0, gray[0]];
+    };
+    convert.gray.lab = function(gray) {
+      return [gray[0], 0, 0];
+    };
+    convert.gray.hex = function(gray) {
+      const val = Math.round(gray[0] / 100 * 255) & 255;
+      const integer = (val << 16) + (val << 8) + val;
+      const string = integer.toString(16).toUpperCase();
+      return "000000".substring(string.length) + string;
+    };
+    convert.rgb.gray = function(rgb) {
+      const val = (rgb[0] + rgb[1] + rgb[2]) / 3;
+      return [val / 255 * 100];
+    };
   }
-};
+});
 
-// node_modules/@inquirer/core/dist/lib/use-state.js
-function useState(defaultValue) {
-  return withPointer((pointer) => {
-    const setState = AsyncResource2.bind(function setState2(newValue) {
-      if (pointer.get() !== newValue) {
-        pointer.set(newValue);
-        handleChange();
+// ../node_modules/color-convert/route.js
+var require_route = __commonJS({
+  "../node_modules/color-convert/route.js"(exports, module) {
+    var conversions = require_conversions();
+    function buildGraph() {
+      const graph = {};
+      const models = Object.keys(conversions);
+      for (let len = models.length, i = 0; i < len; i++) {
+        graph[models[i]] = {
+          // http://jsperf.com/1-vs-infinity
+          // micro-opt, but this is simple.
+          distance: -1,
+          parent: null
+        };
       }
-    });
-    if (pointer.initialized) {
-      return [pointer.get(), setState];
+      return graph;
     }
-    const value = typeof defaultValue === "function" ? defaultValue() : defaultValue;
-    pointer.set(value);
-    return [value, setState];
-  });
-}
-
-// node_modules/@inquirer/core/dist/lib/use-effect.js
+    function deriveBFS(fromModel) {
+      const graph = buildGraph();
+      const queue = [fromModel];
+      graph[fromModel].distance = 0;
+      while (queue.length) {
+        const current = queue.pop();
+        const adjacents = Object.keys(conversions[current]);
+        for (let len = adjacents.length, i = 0; i < len; i++) {
+          const adjacent = adjacents[i];
+          const node = graph[adjacent];
+          if (node.distance === -1) {
+            node.distance = graph[current].distance + 1;
+            node.parent = current;
+            queue.unshift(adjacent);
+          }
+        }
+      }
+      return graph;
+    }
+    function link(from, to) {
+      return function(args2) {
+        return to(from(args2));
+      };
+    }
+    function wrapConversion(toModel, graph) {
+      const path = [graph[toModel].parent, toModel];
+      let fn = conversions[graph[toModel].parent][toModel];
+      let cur = graph[toModel].parent;
+      while (graph[cur].parent) {
+        path.unshift(graph[cur].parent);
+        fn = link(conversions[graph[cur].parent][cur], fn);
+        cur = graph[cur].parent;
+      }
+      fn.conversion = path;
+      return fn;
+    }
+    module.exports = function(fromModel) {
+      const graph = deriveBFS(fromModel);
+      const conversion = {};
+      const models = Object.keys(graph);
+      for (let len = models.length, i = 0; i < len; i++) {
+        const toModel = models[i];
+        const node = graph[toModel];
+        if (node.parent === null) {
+          continue;
+        }
+        conversion[toModel] = wrapConversion(toModel, graph);
+      }
+      return conversion;
+    };
+  }
+});
+
+// ../node_modules/color-convert/index.js
+var require_color_convert = __commonJS({
+  "../node_modules/color-convert/index.js"(exports, module) {
+    var conversions = require_conversions();
+    var route = require_route();
+    var convert = {};
+    var models = Object.keys(conversions);
+    function wrapRaw(fn) {
+      const wrappedFn = function(...args2) {
+        const arg0 = args2[0];
+        if (arg0 === void 0 || arg0 === null) {
+          return arg0;
+        }
+        if (arg0.length > 1) {
+          args2 = arg0;
+        }
+        return fn(args2);
+      };
+      if ("conversion" in fn) {
+        wrappedFn.conversion = fn.conversion;
+      }
+      return wrappedFn;
+    }
+    function wrapRounded(fn) {
+      const wrappedFn = function(...args2) {
+        const arg0 = args2[0];
+        if (arg0 === void 0 || arg0 === null) {
+          return arg0;
+        }
+        if (arg0.length > 1) {
+          args2 = arg0;
+        }
+        const result = fn(args2);
+        if (typeof result === "object") {
+          for (let len = result.length, i = 0; i < len; i++) {
+            result[i] = Math.round(result[i]);
+          }
+        }
+        return result;
+      };
+      if ("conversion" in fn) {
+        wrappedFn.conversion = fn.conversion;
+      }
+      return wrappedFn;
+    }
+    models.forEach((fromModel) => {
+      convert[fromModel] = {};
+      Object.defineProperty(convert[fromModel], "channels", { value: conversions[fromModel].channels });
+      Object.defineProperty(convert[fromModel], "labels", { value: conversions[fromModel].labels });
+      const routes = route(fromModel);
+      const routeModels = Object.keys(routes);
+      routeModels.forEach((toModel) => {
+        const fn = routes[toModel];
+        convert[fromModel][toModel] = wrapRounded(fn);
+        convert[fromModel][toModel].raw = wrapRaw(fn);
+      });
+    });
+    module.exports = convert;
+  }
+});
+
+// ../node_modules/ansi-styles/index.js
+var require_ansi_styles = __commonJS({
+  "../node_modules/ansi-styles/index.js"(exports, module) {
+    "use strict";
+    var wrapAnsi162 = (fn, offset) => (...args2) => {
+      const code = fn(...args2);
+      return `\x1B[${code + offset}m`;
+    };
+    var wrapAnsi2562 = (fn, offset) => (...args2) => {
+      const code = fn(...args2);
+      return `\x1B[${38 + offset};5;${code}m`;
+    };
+    var wrapAnsi16m2 = (fn, offset) => (...args2) => {
+      const rgb = fn(...args2);
+      return `\x1B[${38 + offset};2;${rgb[0]};${rgb[1]};${rgb[2]}m`;
+    };
+    var ansi2ansi = (n) => n;
+    var rgb2rgb = (r, g, b) => [r, g, b];
+    var setLazyProperty = (object, property, get) => {
+      Object.defineProperty(object, property, {
+        get: () => {
+          const value = get();
+          Object.defineProperty(object, property, {
+            value,
+            enumerable: true,
+            configurable: true
+          });
+          return value;
+        },
+        enumerable: true,
+        configurable: true
+      });
+    };
+    var colorConvert;
+    var makeDynamicStyles = (wrap, targetSpace, identity, isBackground) => {
+      if (colorConvert === void 0) {
+        colorConvert = require_color_convert();
+      }
+      const offset = isBackground ? 10 : 0;
+      const styles2 = {};
+      for (const [sourceSpace, suite] of Object.entries(colorConvert)) {
+        const name = sourceSpace === "ansi16" ? "ansi" : sourceSpace;
+        if (sourceSpace === targetSpace) {
+          styles2[name] = wrap(identity, offset);
+        } else if (typeof suite === "object") {
+          styles2[name] = wrap(suite[targetSpace], offset);
+        }
+      }
+      return styles2;
+    };
+    function assembleStyles2() {
+      const codes = /* @__PURE__ */ new Map();
+      const styles2 = {
+        modifier: {
+          reset: [0, 0],
+          // 21 isn't widely supported and 22 does the same thing
+          bold: [1, 22],
+          dim: [2, 22],
+          italic: [3, 23],
+          underline: [4, 24],
+          inverse: [7, 27],
+          hidden: [8, 28],
+          strikethrough: [9, 29]
+        },
+        color: {
+          black: [30, 39],
+          red: [31, 39],
+          green: [32, 39],
+          yellow: [33, 39],
+          blue: [34, 39],
+          magenta: [35, 39],
+          cyan: [36, 39],
+          white: [37, 39],
+          // Bright color
+          blackBright: [90, 39],
+          redBright: [91, 39],
+          greenBright: [92, 39],
+          yellowBright: [93, 39],
+          blueBright: [94, 39],
+          magentaBright: [95, 39],
+          cyanBright: [96, 39],
+          whiteBright: [97, 39]
+        },
+        bgColor: {
+          bgBlack: [40, 49],
+          bgRed: [41, 49],
+          bgGreen: [42, 49],
+          bgYellow: [43, 49],
+          bgBlue: [44, 49],
+          bgMagenta: [45, 49],
+          bgCyan: [46, 49],
+          bgWhite: [47, 49],
+          // Bright color
+          bgBlackBright: [100, 49],
+          bgRedBright: [101, 49],
+          bgGreenBright: [102, 49],
+          bgYellowBright: [103, 49],
+          bgBlueBright: [104, 49],
+          bgMagentaBright: [105, 49],
+          bgCyanBright: [106, 49],
+          bgWhiteBright: [107, 49]
+        }
+      };
+      styles2.color.gray = styles2.color.blackBright;
+      styles2.bgColor.bgGray = styles2.bgColor.bgBlackBright;
+      styles2.color.grey = styles2.color.blackBright;
+      styles2.bgColor.bgGrey = styles2.bgColor.bgBlackBright;
+      for (const [groupName, group] of Object.entries(styles2)) {
+        for (const [styleName, style] of Object.entries(group)) {
+          styles2[styleName] = {
+            open: `\x1B[${style[0]}m`,
+            close: `\x1B[${style[1]}m`
+          };
+          group[styleName] = styles2[styleName];
+          codes.set(style[0], style[1]);
+        }
+        Object.defineProperty(styles2, groupName, {
+          value: group,
+          enumerable: false
+        });
+      }
+      Object.defineProperty(styles2, "codes", {
+        value: codes,
+        enumerable: false
+      });
+      styles2.color.close = "\x1B[39m";
+      styles2.bgColor.close = "\x1B[49m";
+      setLazyProperty(styles2.color, "ansi", () => makeDynamicStyles(wrapAnsi162, "ansi16", ansi2ansi, false));
+      setLazyProperty(styles2.color, "ansi256", () => makeDynamicStyles(wrapAnsi2562, "ansi256", ansi2ansi, false));
+      setLazyProperty(styles2.color, "ansi16m", () => makeDynamicStyles(wrapAnsi16m2, "rgb", rgb2rgb, false));
+      setLazyProperty(styles2.bgColor, "ansi", () => makeDynamicStyles(wrapAnsi162, "ansi16", ansi2ansi, true));
+      setLazyProperty(styles2.bgColor, "ansi256", () => makeDynamicStyles(wrapAnsi2562, "ansi256", ansi2ansi, true));
+      setLazyProperty(styles2.bgColor, "ansi16m", () => makeDynamicStyles(wrapAnsi16m2, "rgb", rgb2rgb, true));
+      return styles2;
+    }
+    Object.defineProperty(module, "exports", {
+      enumerable: true,
+      get: assembleStyles2
+    });
+  }
+});
+
+// ../node_modules/has-flag/index.js
+var require_has_flag = __commonJS({
+  "../node_modules/has-flag/index.js"(exports, module) {
+    "use strict";
+    module.exports = (flag, argv = process.argv) => {
+      const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+      const position = argv.indexOf(prefix + flag);
+      const terminatorPosition = argv.indexOf("--");
+      return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+    };
+  }
+});
+
+// ../node_modules/chalk/node_modules/supports-color/index.js
+var require_supports_color = __commonJS({
+  "../node_modules/chalk/node_modules/supports-color/index.js"(exports, module) {
+    "use strict";
+    var os = __require("os");
+    var tty = __require("tty");
+    var hasFlag = require_has_flag();
+    var { env } = process;
+    var forceColor;
+    if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
+      forceColor = 0;
+    } else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
+      forceColor = 1;
+    }
+    if ("FORCE_COLOR" in env) {
+      if (env.FORCE_COLOR === "true") {
+        forceColor = 1;
+      } else if (env.FORCE_COLOR === "false") {
+        forceColor = 0;
+      } else {
+        forceColor = env.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env.FORCE_COLOR, 10), 3);
+      }
+    }
+    function translateLevel(level) {
+      if (level === 0) {
+        return false;
+      }
+      return {
+        level,
+        hasBasic: true,
+        has256: level >= 2,
+        has16m: level >= 3
+      };
+    }
+    function supportsColor(haveStream, streamIsTTY) {
+      if (forceColor === 0) {
+        return 0;
+      }
+      if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
+        return 3;
+      }
+      if (hasFlag("color=256")) {
+        return 2;
+      }
+      if (haveStream && !streamIsTTY && forceColor === void 0) {
+        return 0;
+      }
+      const min = forceColor || 0;
+      if (env.TERM === "dumb") {
+        return min;
+      }
+      if (process.platform === "win32") {
+        const osRelease = os.release().split(".");
+        if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+          return Number(osRelease[2]) >= 14931 ? 3 : 2;
+        }
+        return 1;
+      }
+      if ("CI" in env) {
+        if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "GITHUB_ACTIONS", "BUILDKITE"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
+          return 1;
+        }
+        return min;
+      }
+      if ("TEAMCITY_VERSION" in env) {
+        return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+      }
+      if (env.COLORTERM === "truecolor") {
+        return 3;
+      }
+      if ("TERM_PROGRAM" in env) {
+        const version = parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+        switch (env.TERM_PROGRAM) {
+          case "iTerm.app":
+            return version >= 3 ? 3 : 2;
+          case "Apple_Terminal":
+            return 2;
+        }
+      }
+      if (/-256(color)?$/i.test(env.TERM)) {
+        return 2;
+      }
+      if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+        return 1;
+      }
+      if ("COLORTERM" in env) {
+        return 1;
+      }
+      return min;
+    }
+    function getSupportLevel(stream) {
+      const level = supportsColor(stream, stream && stream.isTTY);
+      return translateLevel(level);
+    }
+    module.exports = {
+      supportsColor: getSupportLevel,
+      stdout: translateLevel(supportsColor(true, tty.isatty(1))),
+      stderr: translateLevel(supportsColor(true, tty.isatty(2)))
+    };
+  }
+});
+
+// ../node_modules/chalk/source/util.js
+var require_util = __commonJS({
+  "../node_modules/chalk/source/util.js"(exports, module) {
+    "use strict";
+    var stringReplaceAll = (string, substring, replacer) => {
+      let index = string.indexOf(substring);
+      if (index === -1) {
+        return string;
+      }
+      const substringLength = substring.length;
+      let endIndex = 0;
+      let returnValue = "";
+      do {
+        returnValue += string.substr(endIndex, index - endIndex) + substring + replacer;
+        endIndex = index + substringLength;
+        index = string.indexOf(substring, endIndex);
+      } while (index !== -1);
+      returnValue += string.substr(endIndex);
+      return returnValue;
+    };
+    var stringEncaseCRLFWithFirstIndex = (string, prefix, postfix, index) => {
+      let endIndex = 0;
+      let returnValue = "";
+      do {
+        const gotCR = string[index - 1] === "\r";
+        returnValue += string.substr(endIndex, (gotCR ? index - 1 : index) - endIndex) + prefix + (gotCR ? "\r\n" : "\n") + postfix;
+        endIndex = index + 1;
+        index = string.indexOf("\n", endIndex);
+      } while (index !== -1);
+      returnValue += string.substr(endIndex);
+      return returnValue;
+    };
+    module.exports = {
+      stringReplaceAll,
+      stringEncaseCRLFWithFirstIndex
+    };
+  }
+});
+
+// ../node_modules/chalk/source/templates.js
+var require_templates = __commonJS({
+  "../node_modules/chalk/source/templates.js"(exports, module) {
+    "use strict";
+    var TEMPLATE_REGEX = /(?:\\(u(?:[a-f\d]{4}|\{[a-f\d]{1,6}\})|x[a-f\d]{2}|.))|(?:\{(~)?(\w+(?:\([^)]*\))?(?:\.\w+(?:\([^)]*\))?)*)(?:[ \t]|(?=\r?\n)))|(\})|((?:.|[\r\n\f])+?)/gi;
+    var STYLE_REGEX = /(?:^|\.)(\w+)(?:\(([^)]*)\))?/g;
+    var STRING_REGEX = /^(['"])((?:\\.|(?!\1)[^\\])*)\1$/;
+    var ESCAPE_REGEX = /\\(u(?:[a-f\d]{4}|{[a-f\d]{1,6}})|x[a-f\d]{2}|.)|([^\\])/gi;
+    var ESCAPES2 = /* @__PURE__ */ new Map([
+      ["n", "\n"],
+      ["r", "\r"],
+      ["t", "	"],
+      ["b", "\b"],
+      ["f", "\f"],
+      ["v", "\v"],
+      ["0", "\0"],
+      ["\\", "\\"],
+      ["e", "\x1B"],
+      ["a", "\x07"]
+    ]);
+    function unescape(c) {
+      const u = c[0] === "u";
+      const bracket = c[1] === "{";
+      if (u && !bracket && c.length === 5 || c[0] === "x" && c.length === 3) {
+        return String.fromCharCode(parseInt(c.slice(1), 16));
+      }
+      if (u && bracket) {
+        return String.fromCodePoint(parseInt(c.slice(2, -1), 16));
+      }
+      return ESCAPES2.get(c) || c;
+    }
+    function parseArguments(name, arguments_) {
+      const results = [];
+      const chunks = arguments_.trim().split(/\s*,\s*/g);
+      let matches;
+      for (const chunk of chunks) {
+        const number = Number(chunk);
+        if (!Number.isNaN(number)) {
+          results.push(number);
+        } else if (matches = chunk.match(STRING_REGEX)) {
+          results.push(matches[2].replace(ESCAPE_REGEX, (m, escape, character) => escape ? unescape(escape) : character));
+        } else {
+          throw new Error(`Invalid Chalk template style argument: ${chunk} (in style '${name}')`);
+        }
+      }
+      return results;
+    }
+    function parseStyle(style) {
+      STYLE_REGEX.lastIndex = 0;
+      const results = [];
+      let matches;
+      while ((matches = STYLE_REGEX.exec(style)) !== null) {
+        const name = matches[1];
+        if (matches[2]) {
+          const args2 = parseArguments(name, matches[2]);
+          results.push([name].concat(args2));
+        } else {
+          results.push([name]);
+        }
+      }
+      return results;
+    }
+    function buildStyle(chalk2, styles2) {
+      const enabled = {};
+      for (const layer of styles2) {
+        for (const style of layer.styles) {
+          enabled[style[0]] = layer.inverse ? null : style.slice(1);
+        }
+      }
+      let current = chalk2;
+      for (const [styleName, styles3] of Object.entries(enabled)) {
+        if (!Array.isArray(styles3)) {
+          continue;
+        }
+        if (!(styleName in current)) {
+          throw new Error(`Unknown Chalk style: ${styleName}`);
+        }
+        current = styles3.length > 0 ? current[styleName](...styles3) : current[styleName];
+      }
+      return current;
+    }
+    module.exports = (chalk2, temporary) => {
+      const styles2 = [];
+      const chunks = [];
+      let chunk = [];
+      temporary.replace(TEMPLATE_REGEX, (m, escapeCharacter, inverse, style, close, character) => {
+        if (escapeCharacter) {
+          chunk.push(unescape(escapeCharacter));
+        } else if (style) {
+          const string = chunk.join("");
+          chunk = [];
+          chunks.push(styles2.length === 0 ? string : buildStyle(chalk2, styles2)(string));
+          styles2.push({ inverse, styles: parseStyle(style) });
+        } else if (close) {
+          if (styles2.length === 0) {
+            throw new Error("Found extraneous } in Chalk template literal");
+          }
+          chunks.push(buildStyle(chalk2, styles2)(chunk.join("")));
+          chunk = [];
+          styles2.pop();
+        } else {
+          chunk.push(character);
+        }
+      });
+      chunks.push(chunk.join(""));
+      if (styles2.length > 0) {
+        const errMessage = `Chalk template literal is missing ${styles2.length} closing bracket${styles2.length === 1 ? "" : "s"} (\`}\`)`;
+        throw new Error(errMessage);
+      }
+      return chunks.join("");
+    };
+  }
+});
+
+// ../node_modules/chalk/source/index.js
+var require_source = __commonJS({
+  "../node_modules/chalk/source/index.js"(exports, module) {
+    "use strict";
+    var ansiStyles2 = require_ansi_styles();
+    var { stdout: stdoutColor, stderr: stderrColor } = require_supports_color();
+    var {
+      stringReplaceAll,
+      stringEncaseCRLFWithFirstIndex
+    } = require_util();
+    var { isArray } = Array;
+    var levelMapping = [
+      "ansi",
+      "ansi",
+      "ansi256",
+      "ansi16m"
+    ];
+    var styles2 = /* @__PURE__ */ Object.create(null);
+    var applyOptions = (object, options = {}) => {
+      if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
+        throw new Error("The `level` option should be an integer from 0 to 3");
+      }
+      const colorLevel = stdoutColor ? stdoutColor.level : 0;
+      object.level = options.level === void 0 ? colorLevel : options.level;
+    };
+    var ChalkClass = class {
+      constructor(options) {
+        return chalkFactory(options);
+      }
+    };
+    var chalkFactory = (options) => {
+      const chalk3 = {};
+      applyOptions(chalk3, options);
+      chalk3.template = (...arguments_) => chalkTag(chalk3.template, ...arguments_);
+      Object.setPrototypeOf(chalk3, Chalk.prototype);
+      Object.setPrototypeOf(chalk3.template, chalk3);
+      chalk3.template.constructor = () => {
+        throw new Error("`chalk.constructor()` is deprecated. Use `new chalk.Instance()` instead.");
+      };
+      chalk3.template.Instance = ChalkClass;
+      return chalk3.template;
+    };
+    function Chalk(options) {
+      return chalkFactory(options);
+    }
+    for (const [styleName, style] of Object.entries(ansiStyles2)) {
+      styles2[styleName] = {
+        get() {
+          const builder = createBuilder(this, createStyler(style.open, style.close, this._styler), this._isEmpty);
+          Object.defineProperty(this, styleName, { value: builder });
+          return builder;
+        }
+      };
+    }
+    styles2.visible = {
+      get() {
+        const builder = createBuilder(this, this._styler, true);
+        Object.defineProperty(this, "visible", { value: builder });
+        return builder;
+      }
+    };
+    var usedModels = ["rgb", "hex", "keyword", "hsl", "hsv", "hwb", "ansi", "ansi256"];
+    for (const model of usedModels) {
+      styles2[model] = {
+        get() {
+          const { level } = this;
+          return function(...arguments_) {
+            const styler = createStyler(ansiStyles2.color[levelMapping[level]][model](...arguments_), ansiStyles2.color.close, this._styler);
+            return createBuilder(this, styler, this._isEmpty);
+          };
+        }
+      };
+    }
+    for (const model of usedModels) {
+      const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
+      styles2[bgModel] = {
+        get() {
+          const { level } = this;
+          return function(...arguments_) {
+            const styler = createStyler(ansiStyles2.bgColor[levelMapping[level]][model](...arguments_), ansiStyles2.bgColor.close, this._styler);
+            return createBuilder(this, styler, this._isEmpty);
+          };
+        }
+      };
+    }
+    var proto = Object.defineProperties(() => {
+    }, {
+      ...styles2,
+      level: {
+        enumerable: true,
+        get() {
+          return this._generator.level;
+        },
+        set(level) {
+          this._generator.level = level;
+        }
+      }
+    });
+    var createStyler = (open, close, parent) => {
+      let openAll;
+      let closeAll;
+      if (parent === void 0) {
+        openAll = open;
+        closeAll = close;
+      } else {
+        openAll = parent.openAll + open;
+        closeAll = close + parent.closeAll;
+      }
+      return {
+        open,
+        close,
+        openAll,
+        closeAll,
+        parent
+      };
+    };
+    var createBuilder = (self, _styler, _isEmpty) => {
+      const builder = (...arguments_) => {
+        if (isArray(arguments_[0]) && isArray(arguments_[0].raw)) {
+          return applyStyle(builder, chalkTag(builder, ...arguments_));
+        }
+        return applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
+      };
+      Object.setPrototypeOf(builder, proto);
+      builder._generator = self;
+      builder._styler = _styler;
+      builder._isEmpty = _isEmpty;
+      return builder;
+    };
+    var applyStyle = (self, string) => {
+      if (self.level <= 0 || !string) {
+        return self._isEmpty ? "" : string;
+      }
+      let styler = self._styler;
+      if (styler === void 0) {
+        return string;
+      }
+      const { openAll, closeAll } = styler;
+      if (string.indexOf("\x1B") !== -1) {
+        while (styler !== void 0) {
+          string = stringReplaceAll(string, styler.close, styler.open);
+          styler = styler.parent;
+        }
+      }
+      const lfIndex = string.indexOf("\n");
+      if (lfIndex !== -1) {
+        string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
+      }
+      return openAll + string + closeAll;
+    };
+    var template;
+    var chalkTag = (chalk3, ...strings) => {
+      const [firstString] = strings;
+      if (!isArray(firstString) || !isArray(firstString.raw)) {
+        return strings.join(" ");
+      }
+      const arguments_ = strings.slice(1);
+      const parts = [firstString.raw[0]];
+      for (let i = 1; i < firstString.length; i++) {
+        parts.push(
+          String(arguments_[i - 1]).replace(/[{}\\]/g, "\\$&"),
+          String(firstString.raw[i])
+        );
+      }
+      if (template === void 0) {
+        template = require_templates();
+      }
+      return template(chalk3, parts.join(""));
+    };
+    Object.defineProperties(Chalk.prototype, styles2);
+    var chalk2 = Chalk();
+    chalk2.supportsColor = stdoutColor;
+    chalk2.stderr = Chalk({ level: stderrColor ? stderrColor.level : 0 });
+    chalk2.stderr.supportsColor = stderrColor;
+    module.exports = chalk2;
+  }
+});
+
+// node_modules/@inquirer/core/dist/lib/key.js
+var isUpKey = (key, keybindings = []) => (
+  // The up key
+  key.name === "up" || // Vim keybinding: hjkl keys map to left/down/up/right
+  keybindings.includes("vim") && key.name === "k" || // Emacs keybinding: Ctrl+P means "previous" in Emacs navigation conventions
+  keybindings.includes("emacs") && key.ctrl && key.name === "p"
+);
+var isDownKey = (key, keybindings = []) => (
+  // The down key
+  key.name === "down" || // Vim keybinding: hjkl keys map to left/down/up/right
+  keybindings.includes("vim") && key.name === "j" || // Emacs keybinding: Ctrl+N means "next" in Emacs navigation conventions
+  keybindings.includes("emacs") && key.ctrl && key.name === "n"
+);
+var isSpaceKey = (key) => key.name === "space";
+var isBackspaceKey = (key) => key.name === "backspace";
+var isTabKey = (key) => key.name === "tab";
+var isNumberKey = (key) => "1234567890".includes(key.name);
+var isEnterKey = (key) => key.name === "enter" || key.name === "return";
+
+// node_modules/@inquirer/core/dist/lib/errors.js
+var AbortPromptError = class extends Error {
+  name = "AbortPromptError";
+  message = "Prompt was aborted";
+  constructor(options) {
+    super();
+    this.cause = options?.cause;
+  }
+};
+var CancelPromptError = class extends Error {
+  name = "CancelPromptError";
+  message = "Prompt was canceled";
+};
+var ExitPromptError = class extends Error {
+  name = "ExitPromptError";
+};
+var HookError = class extends Error {
+  name = "HookError";
+};
+var ValidationError = class extends Error {
+  name = "ValidationError";
+};
+
+// node_modules/@inquirer/core/dist/lib/use-state.js
+import { AsyncResource as AsyncResource2 } from "node:async_hooks";
+
+// node_modules/@inquirer/core/dist/lib/hook-engine.js
+import { AsyncLocalStorage, AsyncResource } from "node:async_hooks";
+var hookStorage = new AsyncLocalStorage();
+function createStore(rl) {
+  const store = {
+    rl,
+    hooks: [],
+    hooksCleanup: [],
+    hooksEffect: [],
+    index: 0,
+    handleChange() {
+    }
+  };
+  return store;
+}
+function withHooks(rl, cb) {
+  const store = createStore(rl);
+  return hookStorage.run(store, () => {
+    function cycle(render) {
+      store.handleChange = () => {
+        store.index = 0;
+        render();
+      };
+      store.handleChange();
+    }
+    return cb(cycle);
+  });
+}
+function getStore() {
+  const store = hookStorage.getStore();
+  if (!store) {
+    throw new HookError("[Inquirer] Hook functions can only be called from within a prompt");
+  }
+  return store;
+}
+function readline() {
+  return getStore().rl;
+}
+function withUpdates(fn) {
+  const wrapped = (...args2) => {
+    const store = getStore();
+    let shouldUpdate = false;
+    const oldHandleChange = store.handleChange;
+    store.handleChange = () => {
+      shouldUpdate = true;
+    };
+    const returnValue = fn(...args2);
+    if (shouldUpdate) {
+      oldHandleChange();
+    }
+    store.handleChange = oldHandleChange;
+    return returnValue;
+  };
+  return AsyncResource.bind(wrapped);
+}
+function withPointer(cb) {
+  const store = getStore();
+  const { index } = store;
+  const pointer = {
+    get() {
+      return store.hooks[index];
+    },
+    set(value) {
+      store.hooks[index] = value;
+    },
+    initialized: index in store.hooks
+  };
+  const returnValue = cb(pointer);
+  store.index++;
+  return returnValue;
+}
+function handleChange() {
+  getStore().handleChange();
+}
+var effectScheduler = {
+  queue(cb) {
+    const store = getStore();
+    const { index } = store;
+    store.hooksEffect.push(() => {
+      store.hooksCleanup[index]?.();
+      const cleanFn = cb(readline());
+      if (cleanFn != null && typeof cleanFn !== "function") {
+        throw new ValidationError("useEffect return value must be a cleanup function or nothing.");
+      }
+      store.hooksCleanup[index] = cleanFn;
+    });
+  },
+  run() {
+    const store = getStore();
+    withUpdates(() => {
+      store.hooksEffect.forEach((effect) => {
+        effect();
+      });
+      store.hooksEffect.length = 0;
+    })();
+  },
+  clearAll() {
+    const store = getStore();
+    store.hooksCleanup.forEach((cleanFn) => {
+      cleanFn?.();
+    });
+    store.hooksEffect.length = 0;
+    store.hooksCleanup.length = 0;
+  }
+};
+
+// node_modules/@inquirer/core/dist/lib/use-state.js
+function useState(defaultValue) {
+  return withPointer((pointer) => {
+    const setState = AsyncResource2.bind(function setState2(newValue) {
+      if (pointer.get() !== newValue) {
+        pointer.set(newValue);
+        handleChange();
+      }
+    });
+    if (pointer.initialized) {
+      return [pointer.get(), setState];
+    }
+    const value = typeof defaultValue === "function" ? defaultValue() : defaultValue;
+    pointer.set(value);
+    return [value, setState];
+  });
+}
+
+// node_modules/@inquirer/core/dist/lib/use-effect.js
 function useEffect(cb, depArray) {
   withPointer((pointer) => {
     const oldDeps = pointer.get();
@@ -2558,7 +4109,6 @@ async function resolveConfig() {
   }
   const resolved = {
     project: projectConfig.project,
-    environment: projectConfig.environment,
     host: projectConfig.host || globalConfig.host || DEFAULT_HOST,
     namespace: projectConfig.namespace || globalConfig.namespace || DEFAULT_NAMESPACE,
     authToken
@@ -2570,9 +4120,6 @@ function validateResolvedConfig(config) {
   if (!config.project) {
     errors.push("Project name is required");
   }
-  if (!config.environment) {
-    errors.push("Environment name is required");
-  }
   if (!config.host) {
     errors.push(
       "Host URL is required (set globally with: jssm config set host <url>)"
@@ -2617,140 +4164,395 @@ async function getProjects(host, apiKey) {
   const url = `${host}/projects`;
   return apiRequest(url, apiKey);
 }
-async function createEnvironment(host, apiKey, project, name) {
-  const url = `${host}/projects/${project}/envs`;
-  return apiRequest(url, apiKey, {
-    method: "POST",
-    body: JSON.stringify({ name })
-  });
-}
-async function getEnvironments(host, apiKey, project) {
-  const url = `${host}/projects/${project}/envs`;
-  return apiRequest(url, apiKey);
-}
-async function pushEnvFile(host, apiKey, project, environment, content, filename = ".env") {
-  const url = `${host}/projects/${project}/envs/${environment}/push-file`;
+async function pushEnvFile(host, apiKey, project, content, filename = ".env", environment) {
+  const url = `${host}/projects/${project}/files/push`;
+  const body = { content, filename };
+  if (environment) {
+    body.environment = environment;
+  }
   return apiRequest(url, apiKey, {
     method: "POST",
-    body: JSON.stringify({ content, filename })
+    body: JSON.stringify(body)
   });
 }
-async function pullEnvFile(host, apiKey, project, environment, filename = ".env") {
-  const url = `${host}/projects/${project}/envs/${environment}/pull-file?filename=${encodeURIComponent(
+async function pullEnvFile(host, apiKey, project, filename = ".env") {
+  const url = `${host}/projects/${project}/files/pull?filename=${encodeURIComponent(
     filename
   )}`;
   const data = await apiRequest(url, apiKey);
   return data.content;
 }
-async function listEnvFiles(host, apiKey, project, environment) {
-  const url = `${host}/projects/${project}/envs/${environment}/list-files`;
-  const data = await apiRequest(url, apiKey);
-  return data.files;
+async function listEnvFiles(host, apiKey, project) {
+  const url = `${host}/projects/${project}/files/list`;
+  const data = await apiRequest(url, apiKey);
+  return data.files;
+}
+
+// src/utils/repoDetector.ts
+import { readdir, readFile as readFile3, stat } from "fs/promises";
+import { join as join3, relative } from "path";
+function isEnvFile(filename) {
+  return filename === ".env" || filename.startsWith(".env.");
+}
+async function isMonorepo(rootPath) {
+  try {
+    const indicators = [
+      "lerna.json",
+      "nx.json",
+      "pnpm-workspace.yaml",
+      "rush.json"
+    ];
+    for (const indicator of indicators) {
+      try {
+        await stat(join3(rootPath, indicator));
+        return true;
+      } catch {
+      }
+    }
+    const commonDirs = ["packages", "apps", "services"];
+    for (const dir of commonDirs) {
+      try {
+        const dirPath = join3(rootPath, dir);
+        const dirStat = await stat(dirPath);
+        if (dirStat.isDirectory()) {
+          const entries = await readdir(dirPath, { withFileTypes: true });
+          const subdirs = entries.filter((e) => e.isDirectory());
+          if (subdirs.length >= 2) {
+            return true;
+          }
+        }
+      } catch {
+      }
+    }
+    try {
+      const packageJsonPath = join3(rootPath, "package.json");
+      const packageJson = JSON.parse(await readFile3(packageJsonPath, "utf-8"));
+      if (packageJson.workspaces) {
+        return true;
+      }
+    } catch {
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+async function findEnvFiles(rootPath, maxDepth = 10) {
+  const envFiles = [];
+  async function search(currentPath, depth) {
+    if (maxDepth !== -1 && depth > maxDepth)
+      return;
+    try {
+      const entries = await readdir(currentPath, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = join3(currentPath, entry.name);
+        if (entry.isDirectory() && ![
+          "node_modules",
+          ".git",
+          "dist",
+          "build",
+          ".next",
+          "coverage",
+          ".turbo",
+          ".cache",
+          "out",
+          "target"
+        ].includes(entry.name)) {
+          await search(fullPath, depth + 1);
+        } else if (entry.isFile() && isEnvFile(entry.name)) {
+          try {
+            const content = await readFile3(fullPath, "utf-8");
+            const lines = content.split("\n");
+            const variableCount = lines.filter((line) => {
+              const trimmed = line.trim();
+              return trimmed && !trimmed.startsWith("#") && trimmed.includes("=");
+            }).length;
+            envFiles.push({
+              path: fullPath,
+              relativePath: relative(rootPath, fullPath),
+              variableCount
+            });
+          } catch {
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  await search(rootPath, 0);
+  return envFiles;
+}
+async function getRepositoryType(rootPath) {
+  const isMonorepoResult = await isMonorepo(rootPath);
+  return isMonorepoResult ? "monorepo" : "normal";
 }
 
-// src/utils/repoDetector.ts
-import { readdir, readFile as readFile3, stat } from "fs/promises";
-import { join as join3, relative } from "path";
-function isEnvFile(filename) {
-  return filename === ".env" || filename.startsWith(".env.");
-}
-async function isMonorepo(rootPath) {
-  try {
-    const indicators = [
-      "lerna.json",
-      "nx.json",
-      "pnpm-workspace.yaml",
-      "rush.json"
-    ];
-    for (const indicator of indicators) {
-      try {
-        await stat(join3(rootPath, indicator));
-        return true;
-      } catch {
+// src/commands/init.ts
+async function initCommand(args2) {
+  const flags = {};
+  for (let i = 0; i < args2.length; i++) {
+    if (args2[i].startsWith("-")) {
+      const key = args2[i].replace(/^-+/, "");
+      const value = args2[i + 1];
+      if (value && !value.startsWith("-")) {
+        flags[key] = value;
+        i++;
+      } else {
+        flags[key] = "true";
       }
     }
-    const commonDirs = ["packages", "apps", "services"];
-    for (const dir of commonDirs) {
+  }
+  const configExists = await hasLocalConfig();
+  if (configExists && !flags.force && !flags.f) {
+    const projectConfig = await loadProjectConfig();
+    if (projectConfig) {
+      console.log("\u{1F4C1} JSSM project already initialized\n");
+      console.log(`   Project: ${projectConfig.project}`);
+      console.log();
       try {
-        const dirPath = join3(rootPath, dir);
-        const dirStat = await stat(dirPath);
-        if (dirStat.isDirectory()) {
-          const entries = await readdir(dirPath, { withFileTypes: true });
-          const subdirs = entries.filter((e) => e.isDirectory());
-          if (subdirs.length >= 2) {
+        const action = await dist_default6({
+          message: "What would you like to do?",
+          choices: [
+            {
+              name: "\u{1F4E5} Pull - Download .env files from server",
+              value: "pull"
+            },
+            {
+              name: "\u{1F4E4} Push - Upload local .env files to server",
+              value: "push"
+            },
+            {
+              name: "\u{1F504} Reinitialize - Set up a different project",
+              value: "reinit"
+            },
+            { name: "\u274C Cancel", value: "cancel" }
+          ]
+        });
+        if (action === "pull") {
+          await pullCommand([]);
+          return;
+        } else if (action === "push") {
+          await pushCommand([]);
+          return;
+        } else if (action === "cancel") {
+          console.log("\n\u{1F44B} Cancelled");
+          return;
+        }
+        console.log();
+      } catch (error) {
+        if (error.name === "ExitPromptError") {
+          console.log("\n\u{1F44B} Cancelled");
+          return;
+        }
+        throw error;
+      }
+    }
+  }
+  console.log("\u{1F680} JSSM Project Initialization\n");
+  console.log("\u{1F510} Checking authentication...");
+  const authData = await loadAuthData();
+  if (!authData) {
+    console.log("\n\u274C You are not logged in");
+    console.log("\u{1F4A1} Please login or register first:");
+    console.log("   jssm login");
+    console.log("   jssm register");
+    process.exit(1);
+  }
+  console.log(`\u2705 Logged in as ${authData.user.email}
+`);
+  const globalConfig = await loadGlobalConfig();
+  const host = flags.host || flags.h || globalConfig.host;
+  if (!host) {
+    console.error("\u274C Host URL is required");
+    console.error("\u{1F4A1} Set it globally: jssm config set host <url>");
+    process.exit(1);
+  }
+  const authToken = authData.token;
+  console.log("\u{1F50D} Analyzing repository...");
+  const cwd = process.cwd();
+  const repoType = await getRepositoryType(cwd);
+  console.log(`   Repository type: ${repoType}`);
+  const envFiles = await findEnvFiles(cwd);
+  if (envFiles.length > 0) {
+    console.log(`   Found ${envFiles.length} .env file(s)`);
+  } else {
+    console.log(`   No .env files found`);
+  }
+  console.log();
+  let projectName;
+  try {
+    console.log("\u{1F4E6} Loading your projects...");
+    const projects = await getProjects(host, authToken);
+    if (projects.length === 0) {
+      console.log("   No existing projects found\n");
+      projectName = await dist_default4({
+        message: "Project name:",
+        validate: (value) => {
+          if (!value)
+            return "Project name is required";
+          if (!/^[a-z0-9-_.]+$/.test(value)) {
+            return "Project name must contain only lowercase letters, numbers, hyphens, underscores, and dots";
+          }
+          return true;
+        }
+      });
+      console.log(`
+\u{1F4E6} Creating project "${projectName}"...`);
+      await createProject(host, authToken, projectName, repoType);
+      console.log(`\u2705 Project created
+`);
+    } else {
+      const projectChoices = [
+        ...projects.map((p) => ({ name: p.name, value: p.name })),
+        { name: "+ Create new project", value: "__new__" }
+      ];
+      const selectedProject = await dist_default6({
+        message: "Select a project:",
+        choices: projectChoices
+      });
+      if (selectedProject === "__new__") {
+        projectName = await dist_default4({
+          message: "New project name:",
+          validate: (value) => {
+            if (!value)
+              return "Project name is required";
+            if (!/^[a-z0-9-_.]+$/.test(value)) {
+              return "Project name must contain only lowercase letters, numbers, hyphens, underscores, and dots";
+            }
+            if (projects.some((p) => p.name === value)) {
+              return "Project already exists";
+            }
             return true;
           }
+        });
+        console.log(`
+\u{1F4E6} Creating project "${projectName}"...`);
+        await createProject(host, authToken, projectName, repoType);
+        console.log(`\u2705 Project created
+`);
+      } else {
+        projectName = selectedProject;
+      }
+    }
+    if (envFiles.length > 0) {
+      console.log("\u{1F4C4} .env files detected:");
+      envFiles.forEach((file) => {
+        console.log(
+          `   ${file.relativePath} (${file.variableCount} variables)`
+        );
+      });
+      console.log();
+      const shouldUpload = await dist_default3({
+        message: "Would you like to upload variables from .env files?",
+        default: true
+      });
+      if (shouldUpload) {
+        let selectedFileInfos;
+        if (repoType === "monorepo" && envFiles.length > 1) {
+          const fileChoices = envFiles.map((file) => ({
+            name: `${file.relativePath} (${file.variableCount} variables)`,
+            value: file.relativePath
+          }));
+          const selectedPaths = await dist_default2({
+            message: "Select .env files to upload:",
+            choices: fileChoices,
+            validate: (answer) => {
+              if (answer.length === 0) {
+                return "Please select at least one file";
+              }
+              return true;
+            }
+          });
+          selectedFileInfos = envFiles.filter(
+            (f) => selectedPaths.includes(f.relativePath)
+          );
+        } else {
+          selectedFileInfos = [envFiles[0]];
+        }
+        const totalVars = selectedFileInfos.reduce(
+          (sum, f) => sum + f.variableCount,
+          0
+        );
+        console.log(
+          `
+\u{1F4CB} Files to upload (${selectedFileInfos.length} files, ${totalVars} total variables):`
+        );
+        selectedFileInfos.forEach((f) => {
+          console.log(`  ${f.relativePath} (${f.variableCount} variables)`);
+        });
+        const confirmUpload = await dist_default3({
+          message: "\nProceed with upload?",
+          default: true
+        });
+        if (confirmUpload) {
+          console.log(`
+\u2B06\uFE0F  Uploading ${selectedFileInfos.length} file(s)...`);
+          let successCount = 0;
+          let failCount = 0;
+          for (const fileInfo of selectedFileInfos) {
+            try {
+              const { readFile: readFileAsync } = await import("fs/promises");
+              const content = await readFileAsync(fileInfo.path, "utf-8");
+              await pushEnvFile(
+                host,
+                authToken,
+                projectName,
+                content,
+                fileInfo.relativePath
+              );
+              console.log(`  \u2705 ${fileInfo.relativePath}`);
+              successCount++;
+            } catch (error) {
+              console.log(`  \u274C ${fileInfo.relativePath}: ${error.message}`);
+              failCount++;
+            }
+          }
+          if (failCount === 0) {
+            console.log(`\u2705 All files uploaded successfully`);
+          } else {
+            console.log(`
+\u26A0\uFE0F  ${successCount} succeeded, ${failCount} failed`);
+          }
+        } else {
+          console.log("\n\u23ED\uFE0F  Skipping file upload");
         }
-      } catch {
       }
     }
-    try {
-      const packageJsonPath = join3(rootPath, "package.json");
-      const packageJson = JSON.parse(await readFile3(packageJsonPath, "utf-8"));
-      if (packageJson.workspaces) {
-        return true;
-      }
-    } catch {
+    const projectConfig = {
+      project: projectName
+    };
+    if (flags.host && flags.host !== globalConfig.host) {
+      projectConfig.host = flags.host;
     }
-    return false;
-  } catch {
-    return false;
-  }
-}
-async function findEnvFiles(rootPath, maxDepth = 10) {
-  const envFiles = [];
-  async function search(currentPath, depth) {
-    if (maxDepth !== -1 && depth > maxDepth)
-      return;
-    try {
-      const entries = await readdir(currentPath, { withFileTypes: true });
-      for (const entry of entries) {
-        const fullPath = join3(currentPath, entry.name);
-        if (entry.isDirectory() && ![
-          "node_modules",
-          ".git",
-          "dist",
-          "build",
-          ".next",
-          "coverage",
-          ".turbo",
-          ".cache",
-          "out",
-          "target"
-        ].includes(entry.name)) {
-          await search(fullPath, depth + 1);
-        } else if (entry.isFile() && isEnvFile(entry.name)) {
-          try {
-            const content = await readFile3(fullPath, "utf-8");
-            const lines = content.split("\n");
-            const variableCount = lines.filter((line) => {
-              const trimmed = line.trim();
-              return trimmed && !trimmed.startsWith("#") && trimmed.includes("=");
-            }).length;
-            envFiles.push({
-              path: fullPath,
-              relativePath: relative(rootPath, fullPath),
-              variableCount
-            });
-          } catch {
-          }
-        }
-      }
-    } catch {
+    if (flags.namespace && flags.namespace !== globalConfig.namespace) {
+      projectConfig.namespace = flags.namespace;
+    }
+    await saveProjectConfig(projectConfig);
+    console.log(`
+\u2705 Project initialized successfully!`);
+    console.log(`   Config file: .jssm`);
+    console.log(`   Project: ${projectName}`);
+    console.log(`   Repository type: ${repoType}`);
+    console.log(`
+\u{1F4A1} Next steps:`);
+    console.log(`   - Run "jssm pull" to fetch variables`);
+    console.log(`   - Run "jssm sync" to sync variables to .env`);
+    console.log(`   - Run "jssm push" to upload local .env changes`);
+  } catch (error) {
+    if (error.name === "ExitPromptError") {
+      console.log("\n\u274C Initialization cancelled");
+      process.exit(0);
     }
+    console.error(`
+\u274C Error: ${error.message}`);
+    process.exit(1);
   }
-  await search(rootPath, 0);
-  return envFiles;
-}
-async function getRepositoryType(rootPath) {
-  const isMonorepoResult = await isMonorepo(rootPath);
-  return isMonorepoResult ? "monorepo" : "normal";
 }
 
 // src/commands/pull.ts
 import { writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
 import { join as join4, dirname } from "path";
-async function pullCommand(args2) {
+async function pullCommand2(args2) {
   const flags = {};
   let pullAll = false;
   for (let i = 0; i < args2.length; i++) {
@@ -2768,7 +4570,7 @@ async function pullCommand(args2) {
   const config = await resolveConfig();
   if (!config) {
     console.error("\u274C No .jssm configuration found in current directory.");
-    console.error('\u{1F4A1} Run "jssm init -p <project> -e <env>" to initialize.');
+    console.error('\u{1F4A1} Run "jssm init -p <project>" to initialize.');
     process.exit(1);
   }
   const { valid, errors } = validateResolvedConfig(config);
@@ -2778,22 +4580,18 @@ async function pullCommand(args2) {
     process.exit(1);
   }
   const project = flags.p || flags.project || config.project;
-  const environment = flags.e || flags.env || config.environment;
   const output = flags.out;
-  if (project !== config.project || environment !== config.environment) {
-    console.log(`\u26A0\uFE0F  Warning: Pulling from ${project}/${environment}`);
-    console.log(
-      `   This directory is initialized for ${config.project}/${config.environment}`
-    );
+  if (project !== config.project) {
+    console.log(`\u26A0\uFE0F  Warning: Pulling from ${project}`);
+    console.log(`   This directory is initialized for ${config.project}`);
   }
   try {
     if (output) {
-      console.log(`\u{1F4E5} Pulling ${output} from ${project}/${environment}...`);
+      console.log(`\u{1F4E5} Pulling ${output} from ${project}...`);
       const content = await pullEnvFile(
         config.host,
         config.authToken,
         project,
-        environment,
         output
       );
       const outputPath = join4(process.cwd(), output);
@@ -2806,196 +4604,33 @@ async function pullCommand(args2) {
       console.log(`\u2705 Wrote ${output} (${varCount} variables)`);
       return;
     }
-    console.log(`\u{1F4E5} Checking available files in ${project}/${environment}...`);
+    console.log(`\u{1F4E5} Checking available files in ${project}...`);
     const availableFiles = await listEnvFiles(
       config.host,
       config.authToken,
-      project,
-      environment
+      project
     );
     if (availableFiles.length === 0) {
       console.error("\u274C No .env files found on server");
       console.error("\u{1F4A1} Push files first with: jssm push");
       process.exit(1);
     }
-    let selectedFiles = [];
-    if (availableFiles.length === 1) {
-      selectedFiles = [availableFiles[0]];
-      console.log(`\u{1F4C4} Found ${availableFiles[0]} on server`);
-    } else if (pullAll) {
-      selectedFiles = availableFiles;
-      console.log(`\u{1F4C4} Found ${availableFiles.length} files on server`);
-    } else {
-      console.log(`\u{1F4C4} Found ${availableFiles.length} .env files on server:
-`);
-      availableFiles.forEach((file) => {
-        console.log(`   \u2022 ${file}`);
-      });
-      console.log();
-      const pullOption = await dist_default6({
-        message: "What would you like to pull?",
-        choices: [
-          {
-            name: "\u2728 All files",
-            value: "all"
-          },
-          {
-            name: "\u{1F4C1} Select specific files",
-            value: "specific"
-          }
-        ]
-      });
-      if (pullOption === "all") {
-        selectedFiles = availableFiles;
-      } else {
-        const fileChoices = availableFiles.map((file) => ({
-          name: file,
-          value: file,
-          checked: false
-        }));
-        selectedFiles = await dist_default2({
-          message: "Select .env file(s) to pull:",
-          choices: fileChoices,
-          validate: (answer) => {
-            if (answer.length === 0) {
-              return "Please select at least one file";
-            }
-            return true;
-          }
-        });
-      }
-    }
-    if (selectedFiles.length === 1) {
-      console.log(`
-\u{1F4E5} Pulling ${selectedFiles[0]}...`);
-    } else {
-      console.log(`
-\u{1F4E5} Pulling ${selectedFiles.length} files...
-`);
-    }
-    let successCount = 0;
-    let failCount = 0;
-    for (const filename of selectedFiles) {
-      try {
-        const content = await pullEnvFile(
-          config.host,
-          config.authToken,
-          project,
-          environment,
-          filename
-        );
-        const outputPath = join4(process.cwd(), filename);
-        const dir = dirname(outputPath);
-        if (dir !== process.cwd()) {
-          await mkdir3(dir, { recursive: true });
-        }
-        await writeFile3(outputPath, content, "utf-8");
-        const varCount = countVariables(content);
-        if (selectedFiles.length === 1) {
-          console.log(`\u2705 Wrote ${filename} (${varCount} variables)`);
-        } else {
-          console.log(`\u2705 ${filename}: Pulled (${varCount} variables)`);
-        }
-        successCount++;
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        console.error(`\u274C ${filename}: Failed to pull - ${message}`);
-        failCount++;
-      }
-    }
-    if (selectedFiles.length > 1) {
-      console.log(`
-\u{1F4CA} Summary:`);
-      if (successCount > 0) {
-        console.log(`   \u2705 Success: ${successCount} file(s)`);
-      }
-      if (failCount > 0) {
-        console.log(`   \u274C Failed: ${failCount} file(s)`);
-      }
-    }
-    if (failCount > 0 && successCount === 0) {
-      process.exit(1);
-    }
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    console.error("\u274C Failed to pull .env files:", message);
-    process.exit(1);
-  }
-}
-function countVariables(content) {
-  return content.split("\n").filter((line) => {
-    const trimmed = line.trim();
-    return trimmed && !trimmed.startsWith("#") && trimmed.includes("=");
-  }).length;
-}
-
-// src/commands/push.ts
-import { readFile as readFile4 } from "fs/promises";
-import { join as join5 } from "path";
-async function pushCommand(args2) {
-  const flags = {};
-  for (let i = 0; i < args2.length; i++) {
-    if (args2[i].startsWith("-")) {
-      const key = args2[i].replace(/^-+/, "");
-      const value = args2[i + 1];
-      if (value && !value.startsWith("-")) {
-        flags[key] = value;
-        i++;
-      }
-    }
-  }
-  const config = await resolveConfig();
-  if (!config) {
-    console.error("\u274C No .jssm configuration found in current directory.");
-    console.error('\u{1F4A1} Run "jssm init -p <project> -e <env>" to initialize.');
-    process.exit(1);
-  }
-  const { valid, errors } = validateResolvedConfig(config);
-  if (!valid) {
-    console.error("\u274C Configuration is incomplete:");
-    errors.forEach((e) => console.error(`   \u2022 ${e}`));
-    process.exit(1);
-  }
-  const project = flags.p || flags.project || config.project;
-  const environment = flags.e || flags.env || config.environment;
-  let input = flags.in || flags.input;
-  let searchDepth = 10;
-  if (flags.depth) {
-    const parsedDepth = parseInt(flags.depth, 10);
-    if (!isNaN(parsedDepth)) {
-      searchDepth = parsedDepth;
-    }
-  }
-  if (project !== config.project || environment !== config.environment) {
-    console.log(`\u26A0\uFE0F  Warning: Pushing to ${project}/${environment}`);
-    console.log(
-      `   This directory is initialized for ${config.project}/${config.environment}`
-    );
-  }
-  let selectedFiles = [];
-  if (!input) {
-    const cwd = process.cwd();
-    const envFiles = await findEnvFiles(cwd, searchDepth);
-    if (envFiles.length === 0) {
-      console.error("\u274C No .env files found");
-      console.error("\u{1F4A1} Create a .env file or specify one with --input <file>");
-      process.exit(1);
-    } else if (envFiles.length === 1) {
-      selectedFiles = [envFiles[0].relativePath];
-      console.log(
-        `\u{1F4C4} Found ${envFiles[0].relativePath} (${envFiles[0].variableCount} variables)`
-      );
+    let selectedFiles = [];
+    if (availableFiles.length === 1) {
+      selectedFiles = [availableFiles[0]];
+      console.log(`\u{1F4C4} Found ${availableFiles[0]} on server`);
+    } else if (pullAll) {
+      selectedFiles = availableFiles;
+      console.log(`\u{1F4C4} Found ${availableFiles.length} files on server`);
     } else {
-      console.log(`\u{1F4C4} Found ${envFiles.length} .env files:
+      console.log(`\u{1F4C4} Found ${availableFiles.length} .env files on server:
 `);
-      envFiles.forEach((file) => {
-        console.log(
-          `   \u2022 ${file.relativePath} (${file.variableCount} variables)`
-        );
+      availableFiles.forEach((file) => {
+        console.log(`   \u2022 ${file}`);
       });
       console.log();
-      const pushOption = await dist_default6({
-        message: "What would you like to push?",
+      const pullOption = await dist_default6({
+        message: "What would you like to pull?",
         choices: [
           {
             name: "\u2728 All files",
@@ -3007,16 +4642,16 @@ async function pushCommand(args2) {
           }
         ]
       });
-      if (pushOption === "all") {
-        selectedFiles = envFiles.map((f) => f.relativePath);
+      if (pullOption === "all") {
+        selectedFiles = availableFiles;
       } else {
-        const fileChoices = envFiles.map((file) => ({
-          name: `${file.relativePath} (${file.variableCount} variables)`,
-          value: file.relativePath,
+        const fileChoices = availableFiles.map((file) => ({
+          name: file,
+          value: file,
           checked: false
         }));
-        const selected = await dist_default2({
-          message: "Select .env file(s) to push:",
+        selectedFiles = await dist_default2({
+          message: "Select .env file(s) to pull:",
           choices: fileChoices,
           validate: (answer) => {
             if (answer.length === 0) {
@@ -3025,469 +4660,307 @@ async function pushCommand(args2) {
             return true;
           }
         });
-        selectedFiles = selected;
       }
     }
-  } else {
-    selectedFiles = [input];
-  }
-  if (selectedFiles.length === 1) {
-    console.log(
-      `
-\u{1F4E4} Pushing ${selectedFiles[0]} to ${project}/${environment}...`
-    );
-  } else {
-    console.log(
-      `
-\u{1F4E4} Pushing ${selectedFiles.length} files to ${project}/${environment}...
-`
-    );
-  }
-  let successCount = 0;
-  let failCount = 0;
-  for (const file of selectedFiles) {
-    let fileContent = "";
-    let fileSize = 0;
-    try {
-      const inputPath = join5(process.cwd(), file);
-      fileContent = await readFile4(inputPath, "utf-8");
-      fileSize = Buffer.byteLength(fileContent, "utf-8");
-      const variables = parseVariables(fileContent, file);
-      if (variables.length === 0) {
-        console.log(`\u26A0\uFE0F  ${file}: No variables found, skipping`);
-        continue;
-      }
-      const invalidVars = variables.filter((v) => !/^[A-Z0-9_]+$/.test(v.key));
-      if (invalidVars.length > 0) {
-        console.error(`\u274C ${file}: Invalid variable names found:`);
-        invalidVars.forEach(
-          (v) => console.error(
-            `   \u2022 ${v.key} (must contain only uppercase letters, numbers, and underscores)`
-          )
-        );
-        failCount++;
-        continue;
-      }
-      if (fileSize > 8192) {
-        console.error(
-          `\u274C ${file}: File size (${fileSize} bytes) exceeds maximum (8192 bytes)`
+    if (selectedFiles.length === 1) {
+      console.log(`
+\u{1F4E5} Pulling ${selectedFiles[0]}...`);
+    } else {
+      console.log(`
+\u{1F4E5} Pulling ${selectedFiles.length} files...
+`);
+    }
+    let successCount = 0;
+    let failCount = 0;
+    for (const filename of selectedFiles) {
+      try {
+        const content = await pullEnvFile(
+          config.host,
+          config.authToken,
+          project,
+          filename
         );
-        console.error("   Consider reducing comments or splitting variables");
+        const outputPath = join4(process.cwd(), filename);
+        const dir = dirname(outputPath);
+        if (dir !== process.cwd()) {
+          await mkdir3(dir, { recursive: true });
+        }
+        await writeFile3(outputPath, content, "utf-8");
+        const varCount = countVariables(content);
+        if (selectedFiles.length === 1) {
+          console.log(`\u2705 Wrote ${filename} (${varCount} variables)`);
+        } else {
+          console.log(`\u2705 ${filename}: Pulled (${varCount} variables)`);
+        }
+        successCount++;
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`\u274C ${filename}: Failed to pull - ${message}`);
         failCount++;
-        continue;
-      }
-      await pushEnvFile(
-        config.host,
-        config.authToken,
-        project,
-        environment,
-        fileContent,
-        file
-        // Use full relative path, not just filename
-      );
-      if (selectedFiles.length === 1) {
-        console.log(
-          `\u2705 Pushed ${file} (${variables.length} variables) to ${project}/${environment}`
-        );
-      } else {
-        console.log(`\u2705 ${file}: Pushed (${variables.length} variables)`);
       }
-      successCount++;
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      console.error(`\u274C ${file}: Failed to push - ${message}`);
-      failCount++;
     }
-  }
-  if (selectedFiles.length > 1) {
-    console.log(`
+    if (selectedFiles.length > 1) {
+      console.log(`
 \u{1F4CA} Summary:`);
-    console.log(`   \u2705 Success: ${successCount} file(s)`);
-    if (failCount > 0) {
-      console.log(`   \u274C Failed: ${failCount} file(s)`);
-    }
-  }
-  if (failCount > 0) {
-    process.exit(1);
-  }
-}
-function parseVariables(content, filename) {
-  const variables = [];
-  if (filename.endsWith(".json")) {
-    try {
-      const obj = JSON.parse(content);
-      for (const [key, value] of Object.entries(obj)) {
-        variables.push({ key, value: String(value) });
-      }
-      return variables;
-    } catch (error) {
-      throw new Error("Invalid JSON file");
-    }
-  }
-  const lines = content.split("\n");
-  let pendingComment;
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    const trimmed = line.trim();
-    if (trimmed.startsWith("#")) {
-      const commentText = trimmed.substring(1).trim();
-      if (commentText && !commentText.match(/^[=\-]+$/)) {
-        pendingComment = commentText;
-      }
-      continue;
-    }
-    if (!trimmed) {
-      pendingComment = void 0;
-      continue;
-    }
-    const match = trimmed.match(/^([A-Z0-9_]+)=(.*)$/);
-    if (match) {
-      const [, key, valueWithComment] = match;
-      const inlineCommentMatch = valueWithComment.match(
-        /^([^#]*?)\s*#\s*(.+)$/
-      );
-      let value;
-      let comment = pendingComment;
-      if (inlineCommentMatch) {
-        value = inlineCommentMatch[1].trim();
-        comment = inlineCommentMatch[2].trim();
-      } else {
-        value = valueWithComment.trim();
+      if (successCount > 0) {
+        console.log(`   \u2705 Success: ${successCount} file(s)`);
       }
-      const cleanValue = value.replace(/^["']|["']$/g, "");
-      const variable = { key, value: cleanValue };
-      if (comment) {
-        variable.comment = comment;
+      if (failCount > 0) {
+        console.log(`   \u274C Failed: ${failCount} file(s)`);
       }
-      variables.push(variable);
-      pendingComment = void 0;
     }
-  }
-  return variables;
-}
-
-// src/commands/init.ts
-async function initCommand(args2) {
-  const flags = {};
-  for (let i = 0; i < args2.length; i++) {
-    if (args2[i].startsWith("-")) {
-      const key = args2[i].replace(/^-+/, "");
-      const value = args2[i + 1];
-      if (value && !value.startsWith("-")) {
-        flags[key] = value;
-        i++;
-      } else {
-        flags[key] = "true";
-      }
+    if (failCount > 0 && successCount === 0) {
+      process.exit(1);
     }
-  }
-  const configExists = await hasLocalConfig();
-  if (configExists && !flags.force && !flags.f) {
-    const projectConfig = await loadProjectConfig();
-    if (projectConfig) {
-      console.log("\u{1F4C1} JSSM project already initialized\n");
-      console.log(`   Project: ${projectConfig.project}`);
-      console.log(`   Environment: ${projectConfig.environment}`);
-      console.log();
-      try {
-        const action = await dist_default6({
-          message: "What would you like to do?",
-          choices: [
-            {
-              name: "\u{1F4E5} Pull - Download .env files from server",
-              value: "pull"
-            },
-            {
-              name: "\u{1F4E4} Push - Upload local .env files to server",
-              value: "push"
-            },
-            {
-              name: "\u{1F504} Reinitialize - Set up a different project/environment",
-              value: "reinit"
-            },
-            { name: "\u274C Cancel", value: "cancel" }
-          ]
-        });
-        if (action === "pull") {
-          await pullCommand([]);
-          return;
-        } else if (action === "push") {
-          await pushCommand([]);
-          return;
-        } else if (action === "cancel") {
-          console.log("\n\u{1F44B} Cancelled");
-          return;
-        }
-        console.log();
-      } catch (error) {
-        if (error.name === "ExitPromptError") {
-          console.log("\n\u{1F44B} Cancelled");
-          return;
-        }
-        throw error;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error("\u274C Failed to pull .env files:", message);
+    process.exit(1);
+  }
+}
+function countVariables(content) {
+  return content.split("\n").filter((line) => {
+    const trimmed = line.trim();
+    return trimmed && !trimmed.startsWith("#") && trimmed.includes("=");
+  }).length;
+}
+
+// src/commands/push.ts
+import { readFile as readFile4 } from "fs/promises";
+import { join as join5 } from "path";
+async function pushCommand2(args2) {
+  const flags = {};
+  for (let i = 0; i < args2.length; i++) {
+    if (args2[i].startsWith("-")) {
+      const key = args2[i].replace(/^-+/, "");
+      const value = args2[i + 1];
+      if (value && !value.startsWith("-")) {
+        flags[key] = value;
+        i++;
       }
     }
   }
-  console.log("\u{1F680} JSSM Project Initialization\n");
-  console.log("\u{1F510} Checking authentication...");
-  const authData = await loadAuthData();
-  if (!authData) {
-    console.log("\n\u274C You are not logged in");
-    console.log("\u{1F4A1} Please login or register first:");
-    console.log("   jssm login");
-    console.log("   jssm register");
+  const config = await resolveConfig();
+  if (!config) {
+    console.error("\u274C No .jssm configuration found in current directory.");
+    console.error('\u{1F4A1} Run "jssm init -p <project>" to initialize.');
     process.exit(1);
   }
-  console.log(`\u2705 Logged in as ${authData.user.email}
-`);
-  const globalConfig = await loadGlobalConfig();
-  const host = flags.host || flags.h || globalConfig.host;
-  if (!host) {
-    console.error("\u274C Host URL is required");
-    console.error("\u{1F4A1} Set it globally: jssm config set host <url>");
+  const { valid, errors } = validateResolvedConfig(config);
+  if (!valid) {
+    console.error("\u274C Configuration is incomplete:");
+    errors.forEach((e) => console.error(`   \u2022 ${e}`));
     process.exit(1);
   }
-  const authToken = authData.token;
-  console.log("\u{1F50D} Analyzing repository...");
-  const cwd = process.cwd();
-  const repoType = await getRepositoryType(cwd);
-  console.log(`   Repository type: ${repoType}`);
-  const envFiles = await findEnvFiles(cwd);
-  if (envFiles.length > 0) {
-    console.log(`   Found ${envFiles.length} .env file(s)`);
-  } else {
-    console.log(`   No .env files found`);
+  const project = flags.p || flags.project || config.project;
+  const environment = flags.e || flags.env;
+  let input = flags.in || flags.input;
+  let searchDepth = 10;
+  if (flags.depth) {
+    const parsedDepth = parseInt(flags.depth, 10);
+    if (!isNaN(parsedDepth)) {
+      searchDepth = parsedDepth;
+    }
   }
-  console.log();
-  let projectName;
-  let environmentName;
-  try {
-    console.log("\u{1F4E6} Loading your projects...");
-    const projects = await getProjects(host, authToken);
-    if (projects.length === 0) {
-      console.log("   No existing projects found\n");
-      projectName = await dist_default4({
-        message: "Project name:",
-        validate: (value) => {
-          if (!value)
-            return "Project name is required";
-          if (!/^[a-z0-9-_.]+$/.test(value)) {
-            return "Project name must contain only lowercase letters, numbers, hyphens, underscores, and dots";
-          }
-          return true;
-        }
-      });
-      console.log(`
-\u{1F4E6} Creating project "${projectName}"...`);
-      await createProject(host, authToken, projectName, repoType);
-      console.log(`\u2705 Project created
-`);
+  if (project !== config.project) {
+    console.log(`\u26A0\uFE0F  Warning: Pushing to ${project}`);
+    console.log(`   This directory is initialized for ${config.project}`);
+  }
+  let selectedFiles = [];
+  if (!input) {
+    const cwd = process.cwd();
+    const envFiles = await findEnvFiles(cwd, searchDepth);
+    if (envFiles.length === 0) {
+      console.error("\u274C No .env files found");
+      console.error("\u{1F4A1} Create a .env file or specify one with --input <file>");
+      process.exit(1);
+    } else if (envFiles.length === 1) {
+      selectedFiles = [envFiles[0].relativePath];
+      console.log(
+        `\u{1F4C4} Found ${envFiles[0].relativePath} (${envFiles[0].variableCount} variables)`
+      );
     } else {
-      const projectChoices = [
-        ...projects.map((p) => ({ name: p.name, value: p.name })),
-        { name: "+ Create new project", value: "__new__" }
-      ];
-      const selectedProject = await dist_default6({
-        message: "Select a project:",
-        choices: projectChoices
-      });
-      if (selectedProject === "__new__") {
-        projectName = await dist_default4({
-          message: "New project name:",
-          validate: (value) => {
-            if (!value)
-              return "Project name is required";
-            if (!/^[a-z0-9-_.]+$/.test(value)) {
-              return "Project name must contain only lowercase letters, numbers, hyphens, underscores, and dots";
-            }
-            if (projects.some((p) => p.name === value)) {
-              return "Project already exists";
-            }
-            return true;
-          }
-        });
-        console.log(`
-\u{1F4E6} Creating project "${projectName}"...`);
-        await createProject(host, authToken, projectName, repoType);
-        console.log(`\u2705 Project created
+      console.log(`\u{1F4C4} Found ${envFiles.length} .env files:
 `);
-      } else {
-        projectName = selectedProject;
-      }
-    }
-    console.log("\u{1F30D} Loading environments...");
-    const environments = await getEnvironments(host, authToken, projectName);
-    if (environments.length === 0) {
-      console.log("   No existing environments found\n");
-      environmentName = await dist_default4({
-        message: "Environment name:",
-        default: "development",
-        validate: (value) => {
-          if (!value)
-            return "Environment name is required";
-          if (!/^[a-z0-9-_]+$/.test(value)) {
-            return "Environment name must contain only lowercase letters, numbers, hyphens, and underscores";
-          }
-          return true;
-        }
+      envFiles.forEach((file) => {
+        console.log(
+          `   \u2022 ${file.relativePath} (${file.variableCount} variables)`
+        );
       });
-      console.log(`
-\u{1F30D} Creating environment "${environmentName}"...`);
-      await createEnvironment(host, authToken, projectName, environmentName);
-      console.log(`\u2705 Environment created
-`);
-    } else {
-      const envChoices = [
-        ...environments.map((e) => ({ name: e.name, value: e.name })),
-        { name: "+ Create new environment", value: "__new__" }
-      ];
-      const selectedEnv = await dist_default6({
-        message: "Select an environment:",
-        choices: envChoices
+      console.log();
+      const pushOption = await dist_default6({
+        message: "What would you like to push?",
+        choices: [
+          {
+            name: "\u2728 All files",
+            value: "all"
+          },
+          {
+            name: "\u{1F4C1} Select specific files",
+            value: "specific"
+          }
+        ]
       });
-      if (selectedEnv === "__new__") {
-        environmentName = await dist_default4({
-          message: "New environment name:",
-          default: "development",
-          validate: (value) => {
-            if (!value)
-              return "Environment name is required";
-            if (!/^[a-z0-9-_]+$/.test(value)) {
-              return "Environment name must contain only lowercase letters, numbers, hyphens, and underscores";
-            }
-            if (environments.some((e) => e.name === value)) {
-              return "Environment already exists";
+      if (pushOption === "all") {
+        selectedFiles = envFiles.map((f) => f.relativePath);
+      } else {
+        const fileChoices = envFiles.map((file) => ({
+          name: `${file.relativePath} (${file.variableCount} variables)`,
+          value: file.relativePath,
+          checked: false
+        }));
+        const selected = await dist_default2({
+          message: "Select .env file(s) to push:",
+          choices: fileChoices,
+          validate: (answer) => {
+            if (answer.length === 0) {
+              return "Please select at least one file";
             }
             return true;
           }
         });
-        console.log(`
-\u{1F30D} Creating environment "${environmentName}"...`);
-        await createEnvironment(host, authToken, projectName, environmentName);
-        console.log(`\u2705 Environment created
-`);
-      } else {
-        environmentName = selectedEnv;
+        selectedFiles = selected;
       }
     }
-    if (envFiles.length > 0) {
-      console.log("\u{1F4C4} .env files detected:");
-      envFiles.forEach((file) => {
-        console.log(
-          `   ${file.relativePath} (${file.variableCount} variables)`
+  } else {
+    selectedFiles = [input];
+  }
+  const envSuffix = environment ? ` (env: ${environment})` : "";
+  if (selectedFiles.length === 1) {
+    console.log(
+      `
+\u{1F4E4} Pushing ${selectedFiles[0]} to ${project}${envSuffix}...`
+    );
+  } else {
+    console.log(
+      `
+\u{1F4E4} Pushing ${selectedFiles.length} files to ${project}${envSuffix}...
+`
+    );
+  }
+  let successCount = 0;
+  let failCount = 0;
+  for (const file of selectedFiles) {
+    let fileContent = "";
+    let fileSize = 0;
+    try {
+      const inputPath = join5(process.cwd(), file);
+      fileContent = await readFile4(inputPath, "utf-8");
+      fileSize = Buffer.byteLength(fileContent, "utf-8");
+      const variables = parseVariables(fileContent, file);
+      if (variables.length === 0) {
+        console.log(`\u26A0\uFE0F  ${file}: No variables found, skipping`);
+        continue;
+      }
+      const invalidVars = variables.filter((v) => !/^[A-Z0-9_]+$/.test(v.key));
+      if (invalidVars.length > 0) {
+        console.error(`\u274C ${file}: Invalid variable names found:`);
+        invalidVars.forEach(
+          (v) => console.error(
+            `   \u2022 ${v.key} (must contain only uppercase letters, numbers, and underscores)`
+          )
         );
-      });
-      console.log();
-      const shouldUpload = await dist_default3({
-        message: "Would you like to upload variables from .env files?",
-        default: true
-      });
-      if (shouldUpload) {
-        let selectedFileInfos;
-        if (repoType === "monorepo" && envFiles.length > 1) {
-          const fileChoices = envFiles.map((file) => ({
-            name: `${file.relativePath} (${file.variableCount} variables)`,
-            value: file.relativePath
-          }));
-          const selectedPaths = await dist_default2({
-            message: "Select .env files to upload:",
-            choices: fileChoices,
-            validate: (answer) => {
-              if (answer.length === 0) {
-                return "Please select at least one file";
-              }
-              return true;
-            }
-          });
-          selectedFileInfos = envFiles.filter(
-            (f) => selectedPaths.includes(f.relativePath)
-          );
-        } else {
-          selectedFileInfos = [envFiles[0]];
-        }
-        const totalVars = selectedFileInfos.reduce(
-          (sum, f) => sum + f.variableCount,
-          0
+        failCount++;
+        continue;
+      }
+      if (fileSize > 8192) {
+        console.error(
+          `\u274C ${file}: File size (${fileSize} bytes) exceeds maximum (8192 bytes)`
         );
+        console.error("   Consider reducing comments or splitting variables");
+        failCount++;
+        continue;
+      }
+      await pushEnvFile(
+        config.host,
+        config.authToken,
+        project,
+        fileContent,
+        file,
+        // Use full relative path, not just filename
+        environment
+        // Optional environment tag
+      );
+      if (selectedFiles.length === 1) {
         console.log(
-          `
-\u{1F4CB} Files to upload (${selectedFileInfos.length} files, ${totalVars} total variables):`
+          `\u2705 Pushed ${file} (${variables.length} variables) to ${project}${envSuffix}`
         );
-        selectedFileInfos.forEach((f) => {
-          console.log(`  ${f.relativePath} (${f.variableCount} variables)`);
-        });
-        const confirmUpload = await dist_default3({
-          message: "\nProceed with upload?",
-          default: true
-        });
-        if (confirmUpload) {
-          console.log(`
-\u2B06\uFE0F  Uploading ${selectedFileInfos.length} file(s)...`);
-          let successCount = 0;
-          let failCount = 0;
-          for (const fileInfo of selectedFileInfos) {
-            try {
-              const { readFile: readFileAsync } = await import("fs/promises");
-              const content = await readFileAsync(fileInfo.path, "utf-8");
-              await pushEnvFile(
-                host,
-                authToken,
-                projectName,
-                environmentName,
-                content,
-                fileInfo.relativePath
-              );
-              console.log(`  \u2705 ${fileInfo.relativePath}`);
-              successCount++;
-            } catch (error) {
-              console.log(`  \u274C ${fileInfo.relativePath}: ${error.message}`);
-              failCount++;
-            }
-          }
-          if (failCount === 0) {
-            console.log(`\u2705 All files uploaded successfully`);
-          } else {
-            console.log(`
-\u26A0\uFE0F  ${successCount} succeeded, ${failCount} failed`);
-          }
-        } else {
-          console.log("\n\u23ED\uFE0F  Skipping file upload");
-        }
+      } else {
+        console.log(`\u2705 ${file}: Pushed (${variables.length} variables)`);
       }
+      successCount++;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(`\u274C ${file}: Failed to push - ${message}`);
+      failCount++;
     }
-    const namespace = flags.namespace || globalConfig.namespace || DEFAULT_NAMESPACE;
-    const projectConfig = {
-      project: projectName,
-      environment: environmentName
-    };
-    if (flags.host && flags.host !== globalConfig.host) {
-      projectConfig.host = flags.host;
-    }
-    if (flags.namespace && flags.namespace !== globalConfig.namespace) {
-      projectConfig.namespace = flags.namespace;
-    }
-    await saveProjectConfig(projectConfig);
-    console.log(`
-\u2705 Project initialized successfully!`);
-    console.log(`   Config file: .jssm`);
-    console.log(`   Project: ${projectName}`);
-    console.log(`   Environment: ${environmentName}`);
-    console.log(`   Repository type: ${repoType}`);
+  }
+  if (selectedFiles.length > 1) {
     console.log(`
-\u{1F4A1} Next steps:`);
-    console.log(`   - Run "jssm pull" to fetch variables`);
-    console.log(`   - Run "jssm sync" to sync variables to .env`);
-    console.log(`   - Run "jssm push" to upload local .env changes`);
-  } catch (error) {
-    if (error.name === "ExitPromptError") {
-      console.log("\n\u274C Initialization cancelled");
-      process.exit(0);
+\u{1F4CA} Summary:`);
+    console.log(`   \u2705 Success: ${successCount} file(s)`);
+    if (failCount > 0) {
+      console.log(`   \u274C Failed: ${failCount} file(s)`);
     }
-    console.error(`
-\u274C Error: ${error.message}`);
+  }
+  if (failCount > 0) {
     process.exit(1);
   }
 }
+function parseVariables(content, filename) {
+  const variables = [];
+  if (filename.endsWith(".json")) {
+    try {
+      const obj = JSON.parse(content);
+      for (const [key, value] of Object.entries(obj)) {
+        variables.push({ key, value: String(value) });
+      }
+      return variables;
+    } catch (error) {
+      throw new Error("Invalid JSON file");
+    }
+  }
+  const lines = content.split("\n");
+  let pendingComment;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+    if (trimmed.startsWith("#")) {
+      const commentText = trimmed.substring(1).trim();
+      if (commentText && !commentText.match(/^[=\-]+$/)) {
+        pendingComment = commentText;
+      }
+      continue;
+    }
+    if (!trimmed) {
+      pendingComment = void 0;
+      continue;
+    }
+    const match = trimmed.match(/^([A-Z0-9_]+)=(.*)$/);
+    if (match) {
+      const [, key, valueWithComment] = match;
+      const inlineCommentMatch = valueWithComment.match(
+        /^([^#]*?)\s*#\s*(.+)$/
+      );
+      let value;
+      let comment = pendingComment;
+      if (inlineCommentMatch) {
+        value = inlineCommentMatch[1].trim();
+        comment = inlineCommentMatch[2].trim();
+      } else {
+        value = valueWithComment.trim();
+      }
+      const cleanValue = value.replace(/^["']|["']$/g, "");
+      const variable = { key, value: cleanValue };
+      if (comment) {
+        variable.comment = comment;
+      }
+      variables.push(variable);
+      pendingComment = void 0;
+    }
+  }
+  return variables;
+}
 
 // src/commands/sync.ts
 import { writeFile as writeFile4 } from "fs/promises";
@@ -3521,151 +4994,29 @@ async function syncCommand() {
       const trimmed = line.trim();
       return trimmed && !trimmed.startsWith("#") && trimmed.includes("=");
     }).length;
-    console.log(`\u2705 Synced .env file (${varCount} variables)`);
-    console.log(`   Project: ${config.project}`);
-    console.log(`   Environment: ${config.environment}`);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    console.error("\u274C Failed to sync .env file:", message);
-    process.exit(1);
-  }
-}
-
-// src/commands/project.ts
-init_auth();
-async function projectCommand(args2) {
-  const subcommand = args2[0];
-  if (subcommand === "create") {
-    await createProjectCommand(args2.slice(1));
-  } else if (subcommand === "list" || subcommand === "ls") {
-    await listProjectsCommand();
-  } else {
-    printProjectHelp();
-  }
-}
-async function createProjectCommand(args2) {
-  const flags = {};
-  for (let i = 0; i < args2.length; i++) {
-    if (args2[i].startsWith("-")) {
-      const key = args2[i].replace(/^-+/, "");
-      const value = args2[i + 1];
-      if (value && !value.startsWith("-")) {
-        flags[key] = value;
-        i++;
-      }
-    }
-  }
-  const name = flags.n || flags.name || args2[0];
-  const host = flags.host;
-  if (!name) {
-    console.error("Usage: jssm project create <name> [--host <api_url>]");
-    console.error("\nOptions:");
-    console.error("  -n, --name    Project name");
-    console.error("  --host        API host URL (optional if config exists)");
-    process.exit(1);
-  }
-  const authToken = await getAuthToken();
-  if (!authToken) {
-    console.error("\u274C Not logged in");
-    console.error("\u{1F4A1} Run: jssm login");
-    process.exit(1);
-  }
-  const globalConfig = await loadGlobalConfig();
-  const projectConfig = await loadProjectConfig();
-  const finalHost = host || projectConfig?.host || globalConfig.host;
-  if (!finalHost) {
-    console.error("\u274C Host is required");
-    console.error("\u{1F4A1} Set globally: jssm config set host <url>");
-    process.exit(1);
-  }
-  try {
-    console.log(`\u{1F4E6} Creating project "${name}"...`);
-    const project = await createProject(finalHost, authToken, name);
-    console.log(`\u2705 Project "${name}" created successfully`);
-    console.log(`   ID: ${project._id}`);
-    console.log(`   Created: ${new Date(project.createdAt).toLocaleString()}`);
-    console.log("\n\u{1F4A1} Next steps:");
-    console.log(
-      `   - Run "jssm env create <env-name> -p ${name}" to create an environment`
-    );
-    console.log(
-      `   - Run "jssm init -p ${name} -e <env-name>" to configure CLI`
-    );
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    console.error(`\u274C Failed to create project: ${message}`);
-    process.exit(1);
-  }
-}
-async function listProjectsCommand() {
-  const authToken = await getAuthToken();
-  if (!authToken) {
-    console.error("\u274C Not logged in");
-    console.error("\u{1F4A1} Run: jssm login");
-    process.exit(1);
-  }
-  const globalConfig = await loadGlobalConfig();
-  const projectConfig = await loadProjectConfig();
-  const host = projectConfig?.host || globalConfig.host;
-  if (!host) {
-    console.error("\u274C Host is required");
-    console.error("\u{1F4A1} Set globally: jssm config set host <url>");
-    process.exit(1);
-  }
-  try {
-    console.log("\u{1F4E6} Fetching projects...\n");
-    const projects = await getProjects(host, authToken);
-    if (projects.length === 0) {
-      console.log("No projects found.");
-      console.log("\u{1F4A1} Create one with: jssm project create <name>");
-      return;
-    }
-    console.log(`Found ${projects.length} project(s):
-`);
-    projects.forEach((project) => {
-      console.log(`  \u2022 ${project.name}`);
-      console.log(`    ID: ${project._id}`);
-      console.log(
-        `    Created: ${new Date(project.createdAt).toLocaleString()}`
-      );
-      console.log("");
-    });
+    console.log(`\u2705 Synced .env file (${varCount} variables)`);
+    console.log(`   Project: ${config.project}`);
+    console.log(`   Environment: ${config.environment}`);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    console.error(`\u274C Failed to list projects: ${message}`);
+    console.error("\u274C Failed to sync .env file:", message);
     process.exit(1);
   }
 }
-function printProjectHelp() {
-  console.log(`
-JSSM Project Management
-
-Usage:
-  jssm project <command> [options]
-
-Commands:
-  create    Create a new project
-  list      List all projects (alias: ls)
-
-Examples:
-  jssm project create my-app
-  jssm project list
-  `);
-}
 
-// src/commands/env.ts
+// src/commands/project.ts
 init_auth();
-async function envCommand(args2) {
+async function projectCommand(args2) {
   const subcommand = args2[0];
   if (subcommand === "create") {
-    await createEnvCommand(args2.slice(1));
+    await createProjectCommand(args2.slice(1));
   } else if (subcommand === "list" || subcommand === "ls") {
-    await listEnvsCommand(args2.slice(1));
+    await listProjectsCommand();
   } else {
-    printEnvHelp();
+    printProjectHelp();
   }
 }
-async function createEnvCommand(args2) {
+async function createProjectCommand(args2) {
   const flags = {};
   for (let i = 0; i < args2.length; i++) {
     if (args2[i].startsWith("-")) {
@@ -3678,18 +5029,12 @@ async function createEnvCommand(args2) {
     }
   }
   const name = flags.n || flags.name || args2[0];
-  const project = flags.p || flags.project;
   const host = flags.host;
   if (!name) {
-    console.error(
-      "Usage: jssm env create <name> -p <project> [--host <api_url>]"
-    );
+    console.error("Usage: jssm project create <name> [--host <api_url>]");
     console.error("\nOptions:");
-    console.error("  -n, --name       Environment name");
-    console.error("  -p, --project    Project name (required)");
-    console.error(
-      "  --host           API host URL (optional if global config exists)"
-    );
+    console.error("  -n, --name    Project name");
+    console.error("  --host        API host URL (optional if config exists)");
     process.exit(1);
   }
   const authToken = await getAuthToken();
@@ -3700,56 +5045,32 @@ async function createEnvCommand(args2) {
   }
   const globalConfig = await loadGlobalConfig();
   const projectConfig = await loadProjectConfig();
-  const finalProject = project || projectConfig?.project;
   const finalHost = host || projectConfig?.host || globalConfig.host;
-  if (!finalProject) {
-    console.error("\u274C Project name is required");
-    console.error('\u{1F4A1} Either provide -p <project>, or run "jssm init" first');
-    process.exit(1);
-  }
   if (!finalHost) {
     console.error("\u274C Host is required");
     console.error("\u{1F4A1} Set globally: jssm config set host <url>");
     process.exit(1);
   }
   try {
+    console.log(`\u{1F4E6} Creating project "${name}"...`);
+    const project = await createProject(finalHost, authToken, name);
+    console.log(`\u2705 Project "${name}" created successfully`);
+    console.log(`   ID: ${project._id}`);
+    console.log(`   Created: ${new Date(project.createdAt).toLocaleString()}`);
+    console.log("\n\u{1F4A1} Next steps:");
     console.log(
-      `\u{1F30D} Creating environment "${name}" in project "${finalProject}"...`
-    );
-    const env = await createEnvironment(
-      finalHost,
-      authToken,
-      finalProject,
-      name
+      `   - Run "jssm env create <env-name> -p ${name}" to create an environment`
     );
-    console.log(`\u2705 Environment "${name}" created successfully`);
-    console.log(`   ID: ${env._id}`);
-    console.log(`   Project: ${finalProject}`);
-    console.log(`   Created: ${new Date(env.createdAt).toLocaleString()}`);
-    console.log("\n\u{1F4A1} Next steps:");
     console.log(
-      `   - Run "jssm init -p ${finalProject} -e ${name}" to configure CLI`
+      `   - Run "jssm init -p ${name} -e <env-name>" to configure CLI`
     );
-    console.log("   - Add variables via the web UI or API");
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    console.error(`\u274C Failed to create environment: ${message}`);
+    console.error(`\u274C Failed to create project: ${message}`);
     process.exit(1);
   }
 }
-async function listEnvsCommand(args2) {
-  const flags = {};
-  for (let i = 0; i < args2.length; i++) {
-    if (args2[i].startsWith("-")) {
-      const key = args2[i].replace(/^-+/, "");
-      const value = args2[i + 1];
-      if (value && !value.startsWith("-")) {
-        flags[key] = value;
-        i++;
-      }
-    }
-  }
-  const project = flags.p || flags.project;
+async function listProjectsCommand() {
   const authToken = await getAuthToken();
   if (!authToken) {
     console.error("\u274C Not logged in");
@@ -3758,52 +5079,50 @@ async function listEnvsCommand(args2) {
   }
   const globalConfig = await loadGlobalConfig();
   const projectConfig = await loadProjectConfig();
-  const finalProject = project || projectConfig?.project;
   const host = projectConfig?.host || globalConfig.host;
-  if (!finalProject || !host) {
-    console.error("\u274C Project and host are required");
+  if (!host) {
+    console.error("\u274C Host is required");
     console.error("\u{1F4A1} Set globally: jssm config set host <url>");
     process.exit(1);
   }
   try {
-    console.log(`\u{1F30D} Fetching environments for project "${finalProject}"...
-`);
-    const environments = await getEnvironments(host, authToken, finalProject);
-    if (environments.length === 0) {
-      console.log("No environments found.");
-      console.log(
-        `\u{1F4A1} Create one with: jssm env create <name> -p ${finalProject}`
-      );
+    console.log("\u{1F4E6} Fetching projects...\n");
+    const projects = await getProjects(host, authToken);
+    if (projects.length === 0) {
+      console.log("No projects found.");
+      console.log("\u{1F4A1} Create one with: jssm project create <name>");
       return;
     }
-    console.log(`Found ${environments.length} environment(s):
+    console.log(`Found ${projects.length} project(s):
 `);
-    environments.forEach((env) => {
-      console.log(`  \u2022 ${env.name}`);
-      console.log(`    ID: ${env._id}`);
-      console.log(`    Created: ${new Date(env.createdAt).toLocaleString()}`);
+    projects.forEach((project) => {
+      console.log(`  \u2022 ${project.name}`);
+      console.log(`    ID: ${project._id}`);
+      console.log(
+        `    Created: ${new Date(project.createdAt).toLocaleString()}`
+      );
       console.log("");
     });
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    console.error(`\u274C Failed to list environments: ${message}`);
+    console.error(`\u274C Failed to list projects: ${message}`);
     process.exit(1);
   }
 }
-function printEnvHelp() {
+function printProjectHelp() {
   console.log(`
-JSSM Environment Management
+JSSM Project Management
 
 Usage:
-  jssm env <command> [options]
+  jssm project <command> [options]
 
 Commands:
-  create    Create a new environment
-  list      List all environments (alias: ls)
+  create    Create a new project
+  list      List all projects (alias: ls)
 
 Examples:
-  jssm env create staging -p my-app
-  jssm env list -p my-app
+  jssm project create my-app
+  jssm project list
   `);
 }
 
@@ -4081,6 +5400,22 @@ async function loginCommand() {
     } else {
       console.error(`
 \u274C Login failed: ${result.error}`);
+      if (result.isConnectionError && host !== DEFAULT_HOST) {
+        console.log(`
+\u26A0\uFE0F  Current host: ${host}`);
+        console.log(`   Default host: ${DEFAULT_HOST}`);
+        const resetToDefault = await dist_default3({
+          message: "Would you like to reset the host to default?",
+          default: false
+        });
+        if (resetToDefault) {
+          globalConfig.host = DEFAULT_HOST;
+          await saveGlobalConfig(globalConfig);
+          console.log(`
+\u2705 Host reset to default: ${DEFAULT_HOST}`);
+          console.log(`\u{1F4A1} Please try logging in again with 'jssm login'`);
+        }
+      }
       process.exit(1);
     }
   } catch (error) {
@@ -4165,6 +5500,22 @@ async function registerCommand() {
     } else {
       console.error(`
 \u274C Registration failed: ${result.error}`);
+      if (result.isConnectionError && host !== DEFAULT_HOST) {
+        console.log(`
+\u26A0\uFE0F  Current host: ${host}`);
+        console.log(`   Default host: ${DEFAULT_HOST}`);
+        const resetToDefault = await dist_default3({
+          message: "Would you like to reset the host to default?",
+          default: false
+        });
+        if (resetToDefault) {
+          globalConfig.host = DEFAULT_HOST;
+          await saveGlobalConfig(globalConfig);
+          console.log(`
+\u2705 Host reset to default: ${DEFAULT_HOST}`);
+          console.log(`\u{1F4A1} Please try registering again with 'jssm register'`);
+        }
+      }
       process.exit(1);
     }
   } catch (error) {
@@ -4190,10 +5541,378 @@ async function logoutCommand() {
   console.log(`\u2705 Successfully logged out (was logged in as ${authData.user.email})`);
 }
 
+// src/commands/token.ts
+init_auth();
+var import_chalk = __toESM(require_source(), 1);
+async function createToken(args2) {
+  const auth = await loadAuthData();
+  const globalConfig = await loadGlobalConfig();
+  const host = globalConfig.host || DEFAULT_HOST;
+  if (!auth) {
+    console.error(import_chalk.default.red("Not logged in. Run: jssm login"));
+    process.exit(1);
+  }
+  let project = "";
+  let environment = "";
+  let name = "";
+  let expiresIn = "90d";
+  for (let i = 0; i < args2.length; i++) {
+    const arg = args2[i];
+    if (arg === "-p" || arg === "--project") {
+      project = args2[++i] || "";
+    } else if (arg === "-e" || arg === "--env") {
+      environment = args2[++i] || "";
+    } else if (arg === "-n" || arg === "--name") {
+      name = args2[++i] || "";
+    } else if (arg === "--expires") {
+      expiresIn = args2[++i] || "90d";
+    }
+  }
+  if (!project || !environment) {
+    try {
+      const jssmConfig = JSON.parse(await Bun.file(".jssm").text());
+      project = project || jssmConfig.project;
+      environment = environment || jssmConfig.environment;
+    } catch {
+    }
+  }
+  if (!project) {
+    console.error(
+      import_chalk.default.red(
+        "Project required. Use -p <project> or run from a directory with .jssm"
+      )
+    );
+    process.exit(1);
+  }
+  if (!environment) {
+    console.error(
+      import_chalk.default.red(
+        "Environment required. Use -e <env> or run from a directory with .jssm"
+      )
+    );
+    process.exit(1);
+  }
+  if (!name) {
+    name = `token-${Date.now()}`;
+  }
+  console.log(
+    import_chalk.default.blue(`Creating service token for ${project}/${environment}...`)
+  );
+  try {
+    const response = await fetch(
+      `${host}/api/projects/${project}/envs/${environment}/tokens`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${auth.token}`
+        },
+        body: JSON.stringify({ name, expiresIn })
+      }
+    );
+    if (!response.ok) {
+      const error = await response.json();
+      console.error(
+        import_chalk.default.red(`Failed to create token: ${error.error}`)
+      );
+      process.exit(1);
+    }
+    const data = await response.json();
+    console.log();
+    console.log(import_chalk.default.green("\u2713 Service token created successfully!"));
+    console.log();
+    console.log(
+      import_chalk.default.yellow(
+        "\u26A0\uFE0F  IMPORTANT: Save this token now! It will not be shown again."
+      )
+    );
+    console.log();
+    console.log(import_chalk.default.bold("Token:"), import_chalk.default.cyan(data.token));
+    console.log();
+    console.log(import_chalk.default.dim("Token ID:"), data.id);
+    console.log(import_chalk.default.dim("Name:"), data.name);
+    console.log(import_chalk.default.dim("Expires:"), data.expiresAt || "Never");
+    console.log();
+    console.log(import_chalk.default.blue("Usage in Dockerfile:"));
+    console.log(import_chalk.default.dim(`  ENV JSSM_SERVICE_TOKEN=${data.token}`));
+    console.log(import_chalk.default.dim(`  ENV JSSM_HOST=${host}`));
+  } catch (error) {
+    console.error(import_chalk.default.red(`Error: ${error.message}`));
+    process.exit(1);
+  }
+}
+async function listTokens(args2) {
+  const auth = await loadAuthData();
+  const globalConfig = await loadGlobalConfig();
+  const host = globalConfig.host || DEFAULT_HOST;
+  if (!auth) {
+    console.error(import_chalk.default.red("Not logged in. Run: jssm login"));
+    process.exit(1);
+  }
+  let project = "";
+  let environment = "";
+  for (let i = 0; i < args2.length; i++) {
+    const arg = args2[i];
+    if (arg === "-p" || arg === "--project") {
+      project = args2[++i] || "";
+    } else if (arg === "-e" || arg === "--env") {
+      environment = args2[++i] || "";
+    }
+  }
+  if (!project || !environment) {
+    try {
+      const jssmConfig = JSON.parse(await Bun.file(".jssm").text());
+      project = project || jssmConfig.project;
+      environment = environment || jssmConfig.environment;
+    } catch {
+    }
+  }
+  if (!project || !environment) {
+    console.error(
+      import_chalk.default.red(
+        "Project and environment required. Use -p and -e or run from a directory with .jssm"
+      )
+    );
+    process.exit(1);
+  }
+  try {
+    const response = await fetch(
+      `${host}/api/projects/${project}/envs/${environment}/tokens`,
+      {
+        headers: { Authorization: `Bearer ${auth.token}` }
+      }
+    );
+    if (!response.ok) {
+      const error = await response.json();
+      console.error(
+        import_chalk.default.red(`Failed to list tokens: ${error.error}`)
+      );
+      process.exit(1);
+    }
+    const data = await response.json();
+    console.log(
+      import_chalk.default.blue(`
+Service tokens for ${project}/${environment}:
+`)
+    );
+    if (data.tokens.length === 0) {
+      console.log(import_chalk.default.dim("No tokens found."));
+    } else {
+      for (const token of data.tokens) {
+        console.log(import_chalk.default.bold(token.name));
+        console.log(import_chalk.default.dim(`  ID: ${token.id}`));
+        console.log(import_chalk.default.dim(`  Prefix: ${token.tokenPrefix}`));
+        console.log(
+          import_chalk.default.dim(`  Created: ${new Date(token.createdAt).toLocaleString()}`)
+        );
+        console.log(
+          import_chalk.default.dim(
+            `  Expires: ${token.expiresAt ? new Date(token.expiresAt).toLocaleString() : "Never"}`
+          )
+        );
+        console.log(
+          import_chalk.default.dim(
+            `  Last used: ${token.lastUsedAt ? new Date(token.lastUsedAt).toLocaleString() : "Never"}`
+          )
+        );
+        console.log();
+      }
+    }
+  } catch (error) {
+    console.error(import_chalk.default.red(`Error: ${error.message}`));
+    process.exit(1);
+  }
+}
+async function revokeToken(args2) {
+  const auth = await loadAuthData();
+  const globalConfig = await loadGlobalConfig();
+  const host = globalConfig.host || DEFAULT_HOST;
+  if (!auth) {
+    console.error(import_chalk.default.red("Not logged in. Run: jssm login"));
+    process.exit(1);
+  }
+  let project = "";
+  let environment = "";
+  let tokenId = "";
+  for (let i = 0; i < args2.length; i++) {
+    const arg = args2[i];
+    if (arg === "-p" || arg === "--project") {
+      project = args2[++i] || "";
+    } else if (arg === "-e" || arg === "--env") {
+      environment = args2[++i] || "";
+    } else if (arg === "-t" || arg === "--token-id") {
+      tokenId = args2[++i] || "";
+    } else if (!arg.startsWith("-") && !tokenId) {
+      tokenId = arg;
+    }
+  }
+  if (!project || !environment) {
+    try {
+      const jssmConfig = JSON.parse(await Bun.file(".jssm").text());
+      project = project || jssmConfig.project;
+      environment = environment || jssmConfig.environment;
+    } catch {
+    }
+  }
+  if (!project || !environment) {
+    console.error(import_chalk.default.red("Project and environment required."));
+    process.exit(1);
+  }
+  if (!tokenId) {
+    console.error(
+      import_chalk.default.red("Token ID required. Use: jssm token revoke <token-id>")
+    );
+    process.exit(1);
+  }
+  try {
+    const response = await fetch(
+      `${host}/api/projects/${project}/envs/${environment}/tokens/${tokenId}`,
+      {
+        method: "DELETE",
+        headers: { Authorization: `Bearer ${auth.token}` }
+      }
+    );
+    if (!response.ok) {
+      const error = await response.json();
+      console.error(
+        import_chalk.default.red(`Failed to revoke token: ${error.error}`)
+      );
+      process.exit(1);
+    }
+    console.log(import_chalk.default.green("\u2713 Token revoked successfully"));
+  } catch (error) {
+    console.error(import_chalk.default.red(`Error: ${error.message}`));
+    process.exit(1);
+  }
+}
+function showTokenHelp() {
+  console.log(`
+${import_chalk.default.bold("JSSM Token Management")}
+
+Manage service tokens for container-based secrets injection.
+
+${import_chalk.default.bold("Commands:")}
+  jssm token create   Create a new service token
+  jssm token list     List all tokens for a project/environment
+  jssm token revoke   Revoke a token
+
+${import_chalk.default.bold("Options:")}
+  -p, --project <name>    Project name
+  -e, --env <name>        Environment name
+  -n, --name <name>       Token name (for create)
+  --expires <duration>    Expiration: 30d, 90d, 1y, never (default: 90d)
+
+${import_chalk.default.bold("Examples:")}
+  # Create a token for production
+  jssm token create -p my-app -e production -n "deploy-token"
+
+  # Create a token that never expires
+  jssm token create -p my-app -e staging --expires never
+
+  # List all tokens
+  jssm token list -p my-app -e production
+
+  # Revoke a token
+  jssm token revoke <token-id> -p my-app -e production
+
+${import_chalk.default.bold("Usage in Docker:")}
+  ENV JSSM_SERVICE_TOKEN=jssm_xxx...
+  ENV JSSM_HOST=https://jssm.example.com
+  RUN wget -O /usr/local/bin/jssm-init \${JSSM_HOST}/scripts/jssm-init.sh && chmod +x /usr/local/bin/jssm-init
+  ENTRYPOINT ["/usr/local/bin/jssm-init"]
+  CMD ["node", "app.js"]
+`);
+}
+
+// src/utils/versionCheck.ts
+var PACKAGE_NAME = "@saidulbadhon/jssm-cli";
+var CURRENT_VERSION = "1.5.5";
+async function getLatestVersion() {
+  try {
+    const response = await fetch(`https://registry.npmjs.org/${PACKAGE_NAME}`);
+    if (!response.ok) {
+      return null;
+    }
+    const data = await response.json();
+    return data["dist-tags"]?.latest || null;
+  } catch {
+    return null;
+  }
+}
+function isOlderVersion(version1, version2) {
+  const v1Parts = version1.split(".").map(Number);
+  const v2Parts = version2.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    const v1 = v1Parts[i] || 0;
+    const v2 = v2Parts[i] || 0;
+    if (v1 < v2)
+      return true;
+    if (v1 > v2)
+      return false;
+  }
+  return false;
+}
+async function checkVersion(currentCommand) {
+  const skipCommands = ["help", "--help", "-h", "--version", "-v", "version", void 0];
+  if (skipCommands.includes(currentCommand)) {
+    return true;
+  }
+  try {
+    const latestVersion = await getLatestVersion();
+    if (!latestVersion) {
+      return true;
+    }
+    if (!isOlderVersion(CURRENT_VERSION, latestVersion)) {
+      return true;
+    }
+    console.log("");
+    console.log("\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557");
+    console.log("\u2551                    \u26A0\uFE0F  UPDATE REQUIRED                      \u2551");
+    console.log("\u2560\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2563");
+    console.log(`\u2551  Current version: ${CURRENT_VERSION.padEnd(40)}\u2551`);
+    console.log(`\u2551  Latest version:  ${latestVersion.padEnd(40)}\u2551`);
+    console.log("\u2551                                                            \u2551");
+    console.log("\u2551  A new version of JSSM CLI is available!                   \u2551");
+    console.log("\u2551  Please update to continue using the CLI.                  \u2551");
+    console.log("\u2551                                                            \u2551");
+    console.log("\u2551  Run: npm install -g @saidulbadhon/jssm-cli@latest         \u2551");
+    console.log("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D");
+    console.log("");
+    const shouldUpdate = await dist_default3({
+      message: "Do you want to update now?",
+      default: true
+    });
+    if (shouldUpdate) {
+      console.log("\n\u{1F4E6} To update, run:");
+      console.log("   npm install -g @saidulbadhon/jssm-cli@latest");
+      console.log("\nOr if you used a different package manager:");
+      console.log("   yarn global add @saidulbadhon/jssm-cli@latest");
+      console.log("   pnpm add -g @saidulbadhon/jssm-cli@latest");
+      console.log("   bun add -g @saidulbadhon/jssm-cli@latest");
+      console.log("");
+      process.exit(0);
+    } else {
+      console.log("\n\u274C Update required to continue. Please update and try again.\n");
+      process.exit(1);
+    }
+    return false;
+  } catch {
+    return true;
+  }
+}
+function getCurrentVersion() {
+  return CURRENT_VERSION;
+}
+
 // src/index.ts
 var args = process.argv.slice(2);
 var command = args[0];
 async function main() {
+  if (command === "--version" || command === "-v" || command === "version") {
+    console.log(`jssm v${getCurrentVersion()}`);
+    return;
+  }
+  await checkVersion(command);
   switch (command) {
     case "login":
       await loginCommand();
@@ -4208,10 +5927,10 @@ async function main() {
       await initCommand(args.slice(1));
       break;
     case "pull":
-      await pullCommand(args.slice(1));
+      await pullCommand2(args.slice(1));
       break;
     case "push":
-      await pushCommand(args.slice(1));
+      await pushCommand2(args.slice(1));
       break;
     case "sync":
       await syncCommand();
@@ -4222,12 +5941,26 @@ async function main() {
     case "project":
       await projectCommand(args.slice(1));
       break;
-    case "env":
-      await envCommand(args.slice(1));
-      break;
     case "config":
       await configCommand(args.slice(1));
       break;
+    case "token": {
+      const subCommand = args[1];
+      switch (subCommand) {
+        case "create":
+          await createToken(args.slice(2));
+          break;
+        case "list":
+          await listTokens(args.slice(2));
+          break;
+        case "revoke":
+          await revokeToken(args.slice(2));
+          break;
+        default:
+          showTokenHelp();
+      }
+      break;
+    }
     case "help":
     case "--help":
     case "-h":
@@ -4253,13 +5986,14 @@ Commands:
   logout     Logout from your account
   init       Initialize current directory (creates .jssm config file)
   status     Show current configuration
-  pull       Pull variables from configured project/environment
-  push       Push variables from local file to configured project/environment
+  pull       Pull .env files from configured project
+  push       Push .env files to configured project
   sync       Sync variables to .env file
   project    Manage projects (create, list)
-  env        Manage environments (create, list)
   config     Manage global configuration (set, get, list)
+  token      Manage service tokens for container secrets (create, list, revoke)
   help       Show this help message
+  --version  Show CLI version
 
 Setup (recommended):
   # 1. Set global host and login
@@ -4267,35 +6001,43 @@ Setup (recommended):
   jssm register    # or: jssm login
 
   # 2. Initialize a project directory (creates .jssm file)
-  jssm init        # Interactive mode - will prompt for project/env
+  jssm init        # Interactive mode - will prompt for project
 
-  # 3. Pull and push variables
-  jssm pull        # Download variables from backend
-  jssm push        # Upload variables from .env to backend
+  # 3. Pull and push .env files
+  jssm pull        # Download .env files from backend
+  jssm push        # Upload .env files to backend
   jssm sync        # Sync variables to .env file
 
 Quick Start (all-in-one):
   # Initialize with all options (for one-off use)
-  jssm init -p my-app -e production
+  jssm init -p my-app
 
 Advanced:
   # Manage global configuration
   jssm config list
   jssm config set host http://api.example.com
 
-  # Create project and environment separately
+  # Create project
   jssm project create my-app
-  jssm env create staging -p my-app
-  jssm env create production -p my-app
 
-  # List resources
+  # List projects
   jssm project list
-  jssm env list -p my-app
+
+Container Secrets (Docker/ECS/EKS):
+  # Create a service token for container deployment
+  jssm token create -p my-app -n "deploy-token"
+
+  # Use in Dockerfile
+  ENV JSSM_SERVICE_TOKEN=jssm_xxx...
+  ENV JSSM_HOST=https://jssm.example.com
+  RUN wget -O /usr/local/bin/jssm-init \\$JSSM_HOST/scripts/jssm-init.sh
+  ENTRYPOINT ["/usr/local/bin/jssm-init"]
+  CMD ["node", "app.js"]
 
 Note:
   - Global config (~/.jssm/config) stores host and preferences
   - Auth data (~/.jssm/auth) stores your login session
-  - Project config (.jssm) stores project name and environment
+  - Project config (.jssm) stores project name
   - Add .jssm to .gitignore (may contain sensitive overrides)
 
 For more information, visit: https://github.com/yourusername/jssm