@pablozaiden/devbox 0.1.0

package/dist/devbox.js

@@ -0,0 +1,1802 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { realpath } from "node:fs/promises";
+import path3 from "node:path";
+
+// src/core.ts
+import { createHash } from "node:crypto";
+import { existsSync } from "node:fs";
+import { access, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+// node_modules/jsonc-parser/lib/esm/impl/scanner.js
+function createScanner(text, ignoreTrivia = false) {
+  const len = text.length;
+  let pos = 0, value = "", tokenOffset = 0, token = 16, lineNumber = 0, lineStartOffset = 0, tokenLineStartOffset = 0, prevTokenLineStartOffset = 0, scanError = 0;
+  function scanHexDigits(count, exact) {
+    let digits = 0;
+    let value2 = 0;
+    while (digits < count || !exact) {
+      let ch = text.charCodeAt(pos);
+      if (ch >= 48 && ch <= 57) {
+        value2 = value2 * 16 + ch - 48;
+      } else if (ch >= 65 && ch <= 70) {
+        value2 = value2 * 16 + ch - 65 + 10;
+      } else if (ch >= 97 && ch <= 102) {
+        value2 = value2 * 16 + ch - 97 + 10;
+      } else {
+        break;
+      }
+      pos++;
+      digits++;
+    }
+    if (digits < count) {
+      value2 = -1;
+    }
+    return value2;
+  }
+  function setPosition(newPosition) {
+    pos = newPosition;
+    value = "";
+    tokenOffset = 0;
+    token = 16;
+    scanError = 0;
+  }
+  function scanNumber() {
+    let start = pos;
+    if (text.charCodeAt(pos) === 48) {
+      pos++;
+    } else {
+      pos++;
+      while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+      }
+    }
+    if (pos < text.length && text.charCodeAt(pos) === 46) {
+      pos++;
+      if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+        while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+          pos++;
+        }
+      } else {
+        scanError = 3;
+        return text.substring(start, pos);
+      }
+    }
+    let end = pos;
+    if (pos < text.length && (text.charCodeAt(pos) === 69 || text.charCodeAt(pos) === 101)) {
+      pos++;
+      if (pos < text.length && text.charCodeAt(pos) === 43 || text.charCodeAt(pos) === 45) {
+        pos++;
+      }
+      if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+        while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+          pos++;
+        }
+        end = pos;
+      } else {
+        scanError = 3;
+      }
+    }
+    return text.substring(start, end);
+  }
+  function scanString() {
+    let result = "", start = pos;
+    while (true) {
+      if (pos >= len) {
+        result += text.substring(start, pos);
+        scanError = 2;
+        break;
+      }
+      const ch = text.charCodeAt(pos);
+      if (ch === 34) {
+        result += text.substring(start, pos);
+        pos++;
+        break;
+      }
+      if (ch === 92) {
+        result += text.substring(start, pos);
+        pos++;
+        if (pos >= len) {
+          scanError = 2;
+          break;
+        }
+        const ch2 = text.charCodeAt(pos++);
+        switch (ch2) {
+          case 34:
+            result += '"';
+            break;
+          case 92:
+            result += "\\";
+            break;
+          case 47:
+            result += "/";
+            break;
+          case 98:
+            result += "\b";
+            break;
+          case 102:
+            result += "\f";
+            break;
+          case 110:
+            result += `
+`;
+            break;
+          case 114:
+            result += "\r";
+            break;
+          case 116:
+            result += "\t";
+            break;
+          case 117:
+            const ch3 = scanHexDigits(4, true);
+            if (ch3 >= 0) {
+              result += String.fromCharCode(ch3);
+            } else {
+              scanError = 4;
+            }
+            break;
+          default:
+            scanError = 5;
+        }
+        start = pos;
+        continue;
+      }
+      if (ch >= 0 && ch <= 31) {
+        if (isLineBreak(ch)) {
+          result += text.substring(start, pos);
+          scanError = 2;
+          break;
+        } else {
+          scanError = 6;
+        }
+      }
+      pos++;
+    }
+    return result;
+  }
+  function scanNext() {
+    value = "";
+    scanError = 0;
+    tokenOffset = pos;
+    lineStartOffset = lineNumber;
+    prevTokenLineStartOffset = tokenLineStartOffset;
+    if (pos >= len) {
+      tokenOffset = len;
+      return token = 17;
+    }
+    let code = text.charCodeAt(pos);
+    if (isWhiteSpace(code)) {
+      do {
+        pos++;
+        value += String.fromCharCode(code);
+        code = text.charCodeAt(pos);
+      } while (isWhiteSpace(code));
+      return token = 15;
+    }
+    if (isLineBreak(code)) {
+      pos++;
+      value += String.fromCharCode(code);
+      if (code === 13 && text.charCodeAt(pos) === 10) {
+        pos++;
+        value += `
+`;
+      }
+      lineNumber++;
+      tokenLineStartOffset = pos;
+      return token = 14;
+    }
+    switch (code) {
+      case 123:
+        pos++;
+        return token = 1;
+      case 125:
+        pos++;
+        return token = 2;
+      case 91:
+        pos++;
+        return token = 3;
+      case 93:
+        pos++;
+        return token = 4;
+      case 58:
+        pos++;
+        return token = 6;
+      case 44:
+        pos++;
+        return token = 5;
+      case 34:
+        pos++;
+        value = scanString();
+        return token = 10;
+      case 47:
+        const start = pos - 1;
+        if (text.charCodeAt(pos + 1) === 47) {
+          pos += 2;
+          while (pos < len) {
+            if (isLineBreak(text.charCodeAt(pos))) {
+              break;
+            }
+            pos++;
+          }
+          value = text.substring(start, pos);
+          return token = 12;
+        }
+        if (text.charCodeAt(pos + 1) === 42) {
+          pos += 2;
+          const safeLength = len - 1;
+          let commentClosed = false;
+          while (pos < safeLength) {
+            const ch = text.charCodeAt(pos);
+            if (ch === 42 && text.charCodeAt(pos + 1) === 47) {
+              pos += 2;
+              commentClosed = true;
+              break;
+            }
+            pos++;
+            if (isLineBreak(ch)) {
+              if (ch === 13 && text.charCodeAt(pos) === 10) {
+                pos++;
+              }
+              lineNumber++;
+              tokenLineStartOffset = pos;
+            }
+          }
+          if (!commentClosed) {
+            pos++;
+            scanError = 1;
+          }
+          value = text.substring(start, pos);
+          return token = 13;
+        }
+        value += String.fromCharCode(code);
+        pos++;
+        return token = 16;
+      case 45:
+        value += String.fromCharCode(code);
+        pos++;
+        if (pos === len || !isDigit(text.charCodeAt(pos))) {
+          return token = 16;
+        }
+      case 48:
+      case 49:
+      case 50:
+      case 51:
+      case 52:
+      case 53:
+      case 54:
+      case 55:
+      case 56:
+      case 57:
+        value += scanNumber();
+        return token = 11;
+      default:
+        while (pos < len && isUnknownContentCharacter(code)) {
+          pos++;
+          code = text.charCodeAt(pos);
+        }
+        if (tokenOffset !== pos) {
+          value = text.substring(tokenOffset, pos);
+          switch (value) {
+            case "true":
+              return token = 8;
+            case "false":
+              return token = 9;
+            case "null":
+              return token = 7;
+          }
+          return token = 16;
+        }
+        value += String.fromCharCode(code);
+        pos++;
+        return token = 16;
+    }
+  }
+  function isUnknownContentCharacter(code) {
+    if (isWhiteSpace(code) || isLineBreak(code)) {
+      return false;
+    }
+    switch (code) {
+      case 125:
+      case 93:
+      case 123:
+      case 91:
+      case 34:
+      case 58:
+      case 44:
+      case 47:
+        return false;
+    }
+    return true;
+  }
+  function scanNextNonTrivia() {
+    let result;
+    do {
+      result = scanNext();
+    } while (result >= 12 && result <= 15);
+    return result;
+  }
+  return {
+    setPosition,
+    getPosition: () => pos,
+    scan: ignoreTrivia ? scanNextNonTrivia : scanNext,
+    getToken: () => token,
+    getTokenValue: () => value,
+    getTokenOffset: () => tokenOffset,
+    getTokenLength: () => pos - tokenOffset,
+    getTokenStartLine: () => lineStartOffset,
+    getTokenStartCharacter: () => tokenOffset - prevTokenLineStartOffset,
+    getTokenError: () => scanError
+  };
+}
+function isWhiteSpace(ch) {
+  return ch === 32 || ch === 9;
+}
+function isLineBreak(ch) {
+  return ch === 10 || ch === 13;
+}
+function isDigit(ch) {
+  return ch >= 48 && ch <= 57;
+}
+var CharacterCodes;
+(function(CharacterCodes2) {
+  CharacterCodes2[CharacterCodes2["lineFeed"] = 10] = "lineFeed";
+  CharacterCodes2[CharacterCodes2["carriageReturn"] = 13] = "carriageReturn";
+  CharacterCodes2[CharacterCodes2["space"] = 32] = "space";
+  CharacterCodes2[CharacterCodes2["_0"] = 48] = "_0";
+  CharacterCodes2[CharacterCodes2["_1"] = 49] = "_1";
+  CharacterCodes2[CharacterCodes2["_2"] = 50] = "_2";
+  CharacterCodes2[CharacterCodes2["_3"] = 51] = "_3";
+  CharacterCodes2[CharacterCodes2["_4"] = 52] = "_4";
+  CharacterCodes2[CharacterCodes2["_5"] = 53] = "_5";
+  CharacterCodes2[CharacterCodes2["_6"] = 54] = "_6";
+  CharacterCodes2[CharacterCodes2["_7"] = 55] = "_7";
+  CharacterCodes2[CharacterCodes2["_8"] = 56] = "_8";
+  CharacterCodes2[CharacterCodes2["_9"] = 57] = "_9";
+  CharacterCodes2[CharacterCodes2["a"] = 97] = "a";
+  CharacterCodes2[CharacterCodes2["b"] = 98] = "b";
+  CharacterCodes2[CharacterCodes2["c"] = 99] = "c";
+  CharacterCodes2[CharacterCodes2["d"] = 100] = "d";
+  CharacterCodes2[CharacterCodes2["e"] = 101] = "e";
+  CharacterCodes2[CharacterCodes2["f"] = 102] = "f";
+  CharacterCodes2[CharacterCodes2["g"] = 103] = "g";
+  CharacterCodes2[CharacterCodes2["h"] = 104] = "h";
+  CharacterCodes2[CharacterCodes2["i"] = 105] = "i";
+  CharacterCodes2[CharacterCodes2["j"] = 106] = "j";
+  CharacterCodes2[CharacterCodes2["k"] = 107] = "k";
+  CharacterCodes2[CharacterCodes2["l"] = 108] = "l";
+  CharacterCodes2[CharacterCodes2["m"] = 109] = "m";
+  CharacterCodes2[CharacterCodes2["n"] = 110] = "n";
+  CharacterCodes2[CharacterCodes2["o"] = 111] = "o";
+  CharacterCodes2[CharacterCodes2["p"] = 112] = "p";
+  CharacterCodes2[CharacterCodes2["q"] = 113] = "q";
+  CharacterCodes2[CharacterCodes2["r"] = 114] = "r";
+  CharacterCodes2[CharacterCodes2["s"] = 115] = "s";
+  CharacterCodes2[CharacterCodes2["t"] = 116] = "t";
+  CharacterCodes2[CharacterCodes2["u"] = 117] = "u";
+  CharacterCodes2[CharacterCodes2["v"] = 118] = "v";
+  CharacterCodes2[CharacterCodes2["w"] = 119] = "w";
+  CharacterCodes2[CharacterCodes2["x"] = 120] = "x";
+  CharacterCodes2[CharacterCodes2["y"] = 121] = "y";
+  CharacterCodes2[CharacterCodes2["z"] = 122] = "z";
+  CharacterCodes2[CharacterCodes2["A"] = 65] = "A";
+  CharacterCodes2[CharacterCodes2["B"] = 66] = "B";
+  CharacterCodes2[CharacterCodes2["C"] = 67] = "C";
+  CharacterCodes2[CharacterCodes2["D"] = 68] = "D";
+  CharacterCodes2[CharacterCodes2["E"] = 69] = "E";
+  CharacterCodes2[CharacterCodes2["F"] = 70] = "F";
+  CharacterCodes2[CharacterCodes2["G"] = 71] = "G";
+  CharacterCodes2[CharacterCodes2["H"] = 72] = "H";
+  CharacterCodes2[CharacterCodes2["I"] = 73] = "I";
+  CharacterCodes2[CharacterCodes2["J"] = 74] = "J";
+  CharacterCodes2[CharacterCodes2["K"] = 75] = "K";
+  CharacterCodes2[CharacterCodes2["L"] = 76] = "L";
+  CharacterCodes2[CharacterCodes2["M"] = 77] = "M";
+  CharacterCodes2[CharacterCodes2["N"] = 78] = "N";
+  CharacterCodes2[CharacterCodes2["O"] = 79] = "O";
+  CharacterCodes2[CharacterCodes2["P"] = 80] = "P";
+  CharacterCodes2[CharacterCodes2["Q"] = 81] = "Q";
+  CharacterCodes2[CharacterCodes2["R"] = 82] = "R";
+  CharacterCodes2[CharacterCodes2["S"] = 83] = "S";
+  CharacterCodes2[CharacterCodes2["T"] = 84] = "T";
+  CharacterCodes2[CharacterCodes2["U"] = 85] = "U";
+  CharacterCodes2[CharacterCodes2["V"] = 86] = "V";
+  CharacterCodes2[CharacterCodes2["W"] = 87] = "W";
+  CharacterCodes2[CharacterCodes2["X"] = 88] = "X";
+  CharacterCodes2[CharacterCodes2["Y"] = 89] = "Y";
+  CharacterCodes2[CharacterCodes2["Z"] = 90] = "Z";
+  CharacterCodes2[CharacterCodes2["asterisk"] = 42] = "asterisk";
+  CharacterCodes2[CharacterCodes2["backslash"] = 92] = "backslash";
+  CharacterCodes2[CharacterCodes2["closeBrace"] = 125] = "closeBrace";
+  CharacterCodes2[CharacterCodes2["closeBracket"] = 93] = "closeBracket";
+  CharacterCodes2[CharacterCodes2["colon"] = 58] = "colon";
+  CharacterCodes2[CharacterCodes2["comma"] = 44] = "comma";
+  CharacterCodes2[CharacterCodes2["dot"] = 46] = "dot";
+  CharacterCodes2[CharacterCodes2["doubleQuote"] = 34] = "doubleQuote";
+  CharacterCodes2[CharacterCodes2["minus"] = 45] = "minus";
+  CharacterCodes2[CharacterCodes2["openBrace"] = 123] = "openBrace";
+  CharacterCodes2[CharacterCodes2["openBracket"] = 91] = "openBracket";
+  CharacterCodes2[CharacterCodes2["plus"] = 43] = "plus";
+  CharacterCodes2[CharacterCodes2["slash"] = 47] = "slash";
+  CharacterCodes2[CharacterCodes2["formFeed"] = 12] = "formFeed";
+  CharacterCodes2[CharacterCodes2["tab"] = 9] = "tab";
+})(CharacterCodes || (CharacterCodes = {}));
+
+// node_modules/jsonc-parser/lib/esm/impl/string-intern.js
+var cachedSpaces = new Array(20).fill(0).map((_, index) => {
+  return " ".repeat(index);
+});
+var maxCachedValues = 200;
+var cachedBreakLinesWithSpaces = {
+  " ": {
+    "\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return `
+` + " ".repeat(index);
+    }),
+    "\r": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\r" + " ".repeat(index);
+    }),
+    "\r\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return `\r
+` + " ".repeat(index);
+    })
+  },
+  "\t": {
+    "\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return `
+` + "\t".repeat(index);
+    }),
+    "\r": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\r" + "\t".repeat(index);
+    }),
+    "\r\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return `\r
+` + "\t".repeat(index);
+    })
+  }
+};
+
+// node_modules/jsonc-parser/lib/esm/impl/parser.js
+var ParseOptions;
+(function(ParseOptions2) {
+  ParseOptions2.DEFAULT = {
+    allowTrailingComma: false
+  };
+})(ParseOptions || (ParseOptions = {}));
+function parse(text, errors = [], options = ParseOptions.DEFAULT) {
+  let currentProperty = null;
+  let currentParent = [];
+  const previousParents = [];
+  function onValue(value) {
+    if (Array.isArray(currentParent)) {
+      currentParent.push(value);
+    } else if (currentProperty !== null) {
+      currentParent[currentProperty] = value;
+    }
+  }
+  const visitor = {
+    onObjectBegin: () => {
+      const object = {};
+      onValue(object);
+      previousParents.push(currentParent);
+      currentParent = object;
+      currentProperty = null;
+    },
+    onObjectProperty: (name) => {
+      currentProperty = name;
+    },
+    onObjectEnd: () => {
+      currentParent = previousParents.pop();
+    },
+    onArrayBegin: () => {
+      const array = [];
+      onValue(array);
+      previousParents.push(currentParent);
+      currentParent = array;
+      currentProperty = null;
+    },
+    onArrayEnd: () => {
+      currentParent = previousParents.pop();
+    },
+    onLiteralValue: onValue,
+    onError: (error, offset, length) => {
+      errors.push({ error, offset, length });
+    }
+  };
+  visit(text, visitor, options);
+  return currentParent[0];
+}
+function visit(text, visitor, options = ParseOptions.DEFAULT) {
+  const _scanner = createScanner(text, false);
+  const _jsonPath = [];
+  let suppressedCallbacks = 0;
+  function toNoArgVisit(visitFunction) {
+    return visitFunction ? () => suppressedCallbacks === 0 && visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+  }
+  function toOneArgVisit(visitFunction) {
+    return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+  }
+  function toOneArgVisitWithPath(visitFunction) {
+    return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice()) : () => true;
+  }
+  function toBeginVisit(visitFunction) {
+    return visitFunction ? () => {
+      if (suppressedCallbacks > 0) {
+        suppressedCallbacks++;
+      } else {
+        let cbReturn = visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice());
+        if (cbReturn === false) {
+          suppressedCallbacks = 1;
+        }
+      }
+    } : () => true;
+  }
+  function toEndVisit(visitFunction) {
+    return visitFunction ? () => {
+      if (suppressedCallbacks > 0) {
+        suppressedCallbacks--;
+      }
+      if (suppressedCallbacks === 0) {
+        visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter());
+      }
+    } : () => true;
+  }
+  const onObjectBegin = toBeginVisit(visitor.onObjectBegin), onObjectProperty = toOneArgVisitWithPath(visitor.onObjectProperty), onObjectEnd = toEndVisit(visitor.onObjectEnd), onArrayBegin = toBeginVisit(visitor.onArrayBegin), onArrayEnd = toEndVisit(visitor.onArrayEnd), onLiteralValue = toOneArgVisitWithPath(visitor.onLiteralValue), onSeparator = toOneArgVisit(visitor.onSeparator), onComment = toNoArgVisit(visitor.onComment), onError = toOneArgVisit(visitor.onError);
+  const disallowComments = options && options.disallowComments;
+  const allowTrailingComma = options && options.allowTrailingComma;
+  function scanNext() {
+    while (true) {
+      const token = _scanner.scan();
+      switch (_scanner.getTokenError()) {
+        case 4:
+          handleError(14);
+          break;
+        case 5:
+          handleError(15);
+          break;
+        case 3:
+          handleError(13);
+          break;
+        case 1:
+          if (!disallowComments) {
+            handleError(11);
+          }
+          break;
+        case 2:
+          handleError(12);
+          break;
+        case 6:
+          handleError(16);
+          break;
+      }
+      switch (token) {
+        case 12:
+        case 13:
+          if (disallowComments) {
+            handleError(10);
+          } else {
+            onComment();
+          }
+          break;
+        case 16:
+          handleError(1);
+          break;
+        case 15:
+        case 14:
+          break;
+        default:
+          return token;
+      }
+    }
+  }
+  function handleError(error, skipUntilAfter = [], skipUntil = []) {
+    onError(error);
+    if (skipUntilAfter.length + skipUntil.length > 0) {
+      let token = _scanner.getToken();
+      while (token !== 17) {
+        if (skipUntilAfter.indexOf(token) !== -1) {
+          scanNext();
+          break;
+        } else if (skipUntil.indexOf(token) !== -1) {
+          break;
+        }
+        token = scanNext();
+      }
+    }
+  }
+  function parseString(isValue) {
+    const value = _scanner.getTokenValue();
+    if (isValue) {
+      onLiteralValue(value);
+    } else {
+      onObjectProperty(value);
+      _jsonPath.push(value);
+    }
+    scanNext();
+    return true;
+  }
+  function parseLiteral() {
+    switch (_scanner.getToken()) {
+      case 11:
+        const tokenValue = _scanner.getTokenValue();
+        let value = Number(tokenValue);
+        if (isNaN(value)) {
+          handleError(2);
+          value = 0;
+        }
+        onLiteralValue(value);
+        break;
+      case 7:
+        onLiteralValue(null);
+        break;
+      case 8:
+        onLiteralValue(true);
+        break;
+      case 9:
+        onLiteralValue(false);
+        break;
+      default:
+        return false;
+    }
+    scanNext();
+    return true;
+  }
+  function parseProperty() {
+    if (_scanner.getToken() !== 10) {
+      handleError(3, [], [2, 5]);
+      return false;
+    }
+    parseString(false);
+    if (_scanner.getToken() === 6) {
+      onSeparator(":");
+      scanNext();
+      if (!parseValue()) {
+        handleError(4, [], [2, 5]);
+      }
+    } else {
+      handleError(5, [], [2, 5]);
+    }
+    _jsonPath.pop();
+    return true;
+  }
+  function parseObject() {
+    onObjectBegin();
+    scanNext();
+    let needsComma = false;
+    while (_scanner.getToken() !== 2 && _scanner.getToken() !== 17) {
+      if (_scanner.getToken() === 5) {
+        if (!needsComma) {
+          handleError(4, [], []);
+        }
+        onSeparator(",");
+        scanNext();
+        if (_scanner.getToken() === 2 && allowTrailingComma) {
+          break;
+        }
+      } else if (needsComma) {
+        handleError(6, [], []);
+      }
+      if (!parseProperty()) {
+        handleError(4, [], [2, 5]);
+      }
+      needsComma = true;
+    }
+    onObjectEnd();
+    if (_scanner.getToken() !== 2) {
+      handleError(7, [2], []);
+    } else {
+      scanNext();
+    }
+    return true;
+  }
+  function parseArray() {
+    onArrayBegin();
+    scanNext();
+    let isFirstElement = true;
+    let needsComma = false;
+    while (_scanner.getToken() !== 4 && _scanner.getToken() !== 17) {
+      if (_scanner.getToken() === 5) {
+        if (!needsComma) {
+          handleError(4, [], []);
+        }
+        onSeparator(",");
+        scanNext();
+        if (_scanner.getToken() === 4 && allowTrailingComma) {
+          break;
+        }
+      } else if (needsComma) {
+        handleError(6, [], []);
+      }
+      if (isFirstElement) {
+        _jsonPath.push(0);
+        isFirstElement = false;
+      } else {
+        _jsonPath[_jsonPath.length - 1]++;
+      }
+      if (!parseValue()) {
+        handleError(4, [], [4, 5]);
+      }
+      needsComma = true;
+    }
+    onArrayEnd();
+    if (!isFirstElement) {
+      _jsonPath.pop();
+    }
+    if (_scanner.getToken() !== 4) {
+      handleError(8, [4], []);
+    } else {
+      scanNext();
+    }
+    return true;
+  }
+  function parseValue() {
+    switch (_scanner.getToken()) {
+      case 3:
+        return parseArray();
+      case 1:
+        return parseObject();
+      case 10:
+        return parseString(true);
+      default:
+        return parseLiteral();
+    }
+  }
+  scanNext();
+  if (_scanner.getToken() === 17) {
+    if (options.allowEmptyContent) {
+      return true;
+    }
+    handleError(4, [], []);
+    return false;
+  }
+  if (!parseValue()) {
+    handleError(4, [], []);
+    return false;
+  }
+  if (_scanner.getToken() !== 17) {
+    handleError(9, [], []);
+  }
+  return true;
+}
+
+// node_modules/jsonc-parser/lib/esm/main.js
+var ScanError;
+(function(ScanError2) {
+  ScanError2[ScanError2["None"] = 0] = "None";
+  ScanError2[ScanError2["UnexpectedEndOfComment"] = 1] = "UnexpectedEndOfComment";
+  ScanError2[ScanError2["UnexpectedEndOfString"] = 2] = "UnexpectedEndOfString";
+  ScanError2[ScanError2["UnexpectedEndOfNumber"] = 3] = "UnexpectedEndOfNumber";
+  ScanError2[ScanError2["InvalidUnicode"] = 4] = "InvalidUnicode";
+  ScanError2[ScanError2["InvalidEscapeCharacter"] = 5] = "InvalidEscapeCharacter";
+  ScanError2[ScanError2["InvalidCharacter"] = 6] = "InvalidCharacter";
+})(ScanError || (ScanError = {}));
+var SyntaxKind;
+(function(SyntaxKind2) {
+  SyntaxKind2[SyntaxKind2["OpenBraceToken"] = 1] = "OpenBraceToken";
+  SyntaxKind2[SyntaxKind2["CloseBraceToken"] = 2] = "CloseBraceToken";
+  SyntaxKind2[SyntaxKind2["OpenBracketToken"] = 3] = "OpenBracketToken";
+  SyntaxKind2[SyntaxKind2["CloseBracketToken"] = 4] = "CloseBracketToken";
+  SyntaxKind2[SyntaxKind2["CommaToken"] = 5] = "CommaToken";
+  SyntaxKind2[SyntaxKind2["ColonToken"] = 6] = "ColonToken";
+  SyntaxKind2[SyntaxKind2["NullKeyword"] = 7] = "NullKeyword";
+  SyntaxKind2[SyntaxKind2["TrueKeyword"] = 8] = "TrueKeyword";
+  SyntaxKind2[SyntaxKind2["FalseKeyword"] = 9] = "FalseKeyword";
+  SyntaxKind2[SyntaxKind2["StringLiteral"] = 10] = "StringLiteral";
+  SyntaxKind2[SyntaxKind2["NumericLiteral"] = 11] = "NumericLiteral";
+  SyntaxKind2[SyntaxKind2["LineCommentTrivia"] = 12] = "LineCommentTrivia";
+  SyntaxKind2[SyntaxKind2["BlockCommentTrivia"] = 13] = "BlockCommentTrivia";
+  SyntaxKind2[SyntaxKind2["LineBreakTrivia"] = 14] = "LineBreakTrivia";
+  SyntaxKind2[SyntaxKind2["Trivia"] = 15] = "Trivia";
+  SyntaxKind2[SyntaxKind2["Unknown"] = 16] = "Unknown";
+  SyntaxKind2[SyntaxKind2["EOF"] = 17] = "EOF";
+})(SyntaxKind || (SyntaxKind = {}));
+var parse2 = parse;
+var ParseErrorCode;
+(function(ParseErrorCode2) {
+  ParseErrorCode2[ParseErrorCode2["InvalidSymbol"] = 1] = "InvalidSymbol";
+  ParseErrorCode2[ParseErrorCode2["InvalidNumberFormat"] = 2] = "InvalidNumberFormat";
+  ParseErrorCode2[ParseErrorCode2["PropertyNameExpected"] = 3] = "PropertyNameExpected";
+  ParseErrorCode2[ParseErrorCode2["ValueExpected"] = 4] = "ValueExpected";
+  ParseErrorCode2[ParseErrorCode2["ColonExpected"] = 5] = "ColonExpected";
+  ParseErrorCode2[ParseErrorCode2["CommaExpected"] = 6] = "CommaExpected";
+  ParseErrorCode2[ParseErrorCode2["CloseBraceExpected"] = 7] = "CloseBraceExpected";
+  ParseErrorCode2[ParseErrorCode2["CloseBracketExpected"] = 8] = "CloseBracketExpected";
+  ParseErrorCode2[ParseErrorCode2["EndOfFileExpected"] = 9] = "EndOfFileExpected";
+  ParseErrorCode2[ParseErrorCode2["InvalidCommentToken"] = 10] = "InvalidCommentToken";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfComment"] = 11] = "UnexpectedEndOfComment";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfString"] = 12] = "UnexpectedEndOfString";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfNumber"] = 13] = "UnexpectedEndOfNumber";
+  ParseErrorCode2[ParseErrorCode2["InvalidUnicode"] = 14] = "InvalidUnicode";
+  ParseErrorCode2[ParseErrorCode2["InvalidEscapeCharacter"] = 15] = "InvalidEscapeCharacter";
+  ParseErrorCode2[ParseErrorCode2["InvalidCharacter"] = 16] = "InvalidCharacter";
+})(ParseErrorCode || (ParseErrorCode = {}));
+
+// src/constants.ts
+var CLI_NAME = "devbox";
+var LEGACY_GENERATED_CONFIG_BASENAME = ".devbox.generated.devcontainer.json";
+var MANAGED_LABEL_KEY = "devbox.managed";
+var WORKSPACE_LABEL_KEY = "devbox.workspace";
+var SSH_AUTH_SOCK_TARGET = "/tmp/devbox-ssh-auth.sock";
+var DOCKER_DESKTOP_SSH_AUTH_SOCK_SOURCE = "/run/host-services/ssh-auth.sock";
+var KNOWN_HOSTS_TARGET = "/tmp/devbox-known_hosts";
+var RUNNER_CRED_FILENAME = ".sshcred";
+var RUNNER_HOST_KEYS_DIRNAME = ".devbox-ssh-host-keys";
+var RUNNER_URL = "https://raw.githubusercontent.com/PabloZaiden/ssh-server-runner/main/ssh-server.sh";
+var STATE_VERSION = 1;
+
+// src/core.ts
+class UserError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "UserError";
+  }
+}
+function helpText() {
+  return `${CLI_NAME} - manage a devcontainer plus ssh-server-runner
+
+Usage:
+  ${CLI_NAME} [port] [--allow-missing-ssh]
+  ${CLI_NAME} up [port] [--allow-missing-ssh]
+  ${CLI_NAME} rebuild [port] [--allow-missing-ssh]
+  ${CLI_NAME} down
+  ${CLI_NAME} --help
+
+Notes:
+  - The same port is published on host and container.
+  - If no port is provided for up/rebuild, the last stored port for this workspace is reused.
+  - Pass --allow-missing-ssh to continue without SSH agent sharing when no usable SSH agent socket is available.
+  - Only image/Dockerfile-based devcontainers are supported in v1.`;
+}
+function parseArgs(argv) {
+  const args = [...argv];
+  if (args.length === 0) {
+    return { command: "up", allowMissingSsh: false };
+  }
+  let command = "up";
+  const first = args[0];
+  if (first === "up" || first === "down" || first === "rebuild" || first === "help") {
+    command = first;
+    args.shift();
+  } else if (first === "--help" || first === "-h") {
+    return { command: "help", allowMissingSsh: false };
+  }
+  let port;
+  let allowMissingSsh = false;
+  const positionals = [];
+  for (let index = 0;index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--help" || arg === "-h") {
+      return { command: "help", allowMissingSsh: false };
+    }
+    if (arg === "--allow-missing-ssh") {
+      allowMissingSsh = true;
+      continue;
+    }
+    if (arg === "--port" || arg === "-p") {
+      const value = args[index + 1];
+      if (!value) {
+        throw new UserError("Expected a value after --port.");
+      }
+      port = parsePort(value);
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--port=")) {
+      port = parsePort(arg.slice("--port=".length));
+      continue;
+    }
+    if (arg.startsWith("-")) {
+      throw new UserError(`Unknown option: ${arg}`);
+    }
+    positionals.push(arg);
+  }
+  if (positionals.length > 1) {
+    throw new UserError(`Unexpected extra argument: ${positionals[1]}`);
+  }
+  if (positionals[0]) {
+    if (command === "down") {
+      throw new UserError("The down command does not accept a port.");
+    }
+    port = parsePort(positionals[0]);
+  }
+  if (command === "down" && port !== undefined) {
+    throw new UserError("The down command does not accept a port.");
+  }
+  return { command, port, allowMissingSsh };
+}
+function parsePort(raw) {
+  if (!/^\d+$/.test(raw)) {
+    throw new UserError(`Invalid port: ${raw}`);
+  }
+  const port = Number(raw);
+  if (!Number.isInteger(port) || port < 1 || port > 65535) {
+    throw new UserError(`Port must be between 1 and 65535. Received: ${raw}`);
+  }
+  return port;
+}
+function hashWorkspacePath(workspacePath) {
+  return createHash("sha256").update(workspacePath).digest("hex").slice(0, 16);
+}
+function getManagedLabels(workspaceHash) {
+  return {
+    [MANAGED_LABEL_KEY]: "true",
+    [WORKSPACE_LABEL_KEY]: workspaceHash
+  };
+}
+function getStateRoot() {
+  if (process.platform === "darwin") {
+    return path.join(os.homedir(), "Library", "Application Support", CLI_NAME);
+  }
+  const xdgStateHome = process.env.XDG_STATE_HOME;
+  if (xdgStateHome) {
+    return path.join(xdgStateHome, CLI_NAME);
+  }
+  return path.join(os.homedir(), ".local", "state", CLI_NAME);
+}
+function getWorkspaceStateDir(workspacePath) {
+  return path.join(getStateRoot(), "workspaces", hashWorkspacePath(workspacePath));
+}
+function getWorkspaceStateFile(workspacePath) {
+  return path.join(getWorkspaceStateDir(workspacePath), "state.json");
+}
+function getWorkspaceUserDataDir(workspacePath) {
+  return path.join(getWorkspaceStateDir(workspacePath), "user-data");
+}
+function getDefaultRemoteWorkspaceFolder(workspacePath) {
+  return path.posix.join("/workspaces", path.basename(workspacePath));
+}
+function getManagedContainerName(workspacePath, port) {
+  const projectName = path.basename(workspacePath);
+  const normalized = projectName.toLowerCase().replace(/[^a-z0-9_.-]+/g, "-").replace(/^-+/, "").replace(/-+$/, "").replace(/-+/g, "-");
+  const safeProjectName = normalized.length > 0 ? normalized : hashWorkspacePath(workspacePath);
+  return `devbox-${safeProjectName.slice(0, 48)}-${port}`;
+}
+async function loadWorkspaceState(workspacePath) {
+  const statePath = getWorkspaceStateFile(workspacePath);
+  if (!existsSync(statePath)) {
+    return null;
+  }
+  const raw = await readFile(statePath, "utf8");
+  const parsed = JSON.parse(raw);
+  if (parsed.version !== STATE_VERSION || typeof parsed.workspacePath !== "string" || typeof parsed.workspaceHash !== "string" || typeof parsed.port !== "number" || typeof parsed.generatedConfigPath !== "string" || typeof parsed.sourceConfigPath !== "string" || typeof parsed.userDataDir !== "string" || !parsed.labels || typeof parsed.labels !== "object") {
+    throw new UserError(`State file is invalid: ${statePath}`);
+  }
+  return parsed;
+}
+async function saveWorkspaceState(state) {
+  const stateDir = getWorkspaceStateDir(state.workspacePath);
+  await mkdir(stateDir, { recursive: true });
+  await writeFile(getWorkspaceStateFile(state.workspacePath), `${JSON.stringify(state, null, 2)}
+`, "utf8");
+}
+async function deleteWorkspaceState(workspacePath) {
+  await rm(getWorkspaceStateDir(workspacePath), { recursive: true, force: true });
+}
+function resolvePort(command, explicitPort, state) {
+  if (command === "down" || command === "help") {
+    throw new UserError(`resolvePort cannot be used for ${command}.`);
+  }
+  if (explicitPort !== undefined) {
+    return explicitPort;
+  }
+  if (state) {
+    return state.port;
+  }
+  throw new UserError(`No port was provided and no previous port is stored for this workspace. Run \`${CLI_NAME} <port>\` first.`);
+}
+async function discoverDevcontainerConfig(workspacePath) {
+  const candidates = [
+    path.join(workspacePath, ".devcontainer", "devcontainer.json"),
+    path.join(workspacePath, ".devcontainer.json")
+  ];
+  for (const candidate of candidates) {
+    if (!existsSync(candidate)) {
+      continue;
+    }
+    const content = await readFile(candidate, "utf8");
+    const errors = [];
+    const parsed = parse2(content, errors, {
+      allowTrailingComma: true,
+      disallowComments: false
+    });
+    if (errors.length > 0) {
+      const details = errors.map((error) => `${error.error}@${error.offset}`).join(", ");
+      throw new UserError(`Could not parse ${candidate} as JSONC (${details}).`);
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new UserError(`${candidate} must contain a JSON object.`);
+    }
+    const config = parsed;
+    validateSupportedDevcontainerConfig(config);
+    return { path: candidate, config };
+  }
+  throw new UserError(`No devcontainer definition was found in ${workspacePath}. Expected .devcontainer/devcontainer.json or .devcontainer.json.`);
+}
+function validateSupportedDevcontainerConfig(config) {
+  if (config.dockerComposeFile !== undefined) {
+    throw new UserError("dockerComposeFile-based devcontainers are not supported in v1.");
+  }
+  const hasImage = typeof config.image === "string" && config.image.trim().length > 0;
+  const hasDockerFile = typeof config.dockerFile === "string" && config.dockerFile.trim().length > 0;
+  const build = asRecord(config.build);
+  const hasBuildDockerfile = typeof build?.dockerfile === "string" && build.dockerfile.trim().length > 0;
+  if (!hasImage && !hasDockerFile && !hasBuildDockerfile) {
+    throw new UserError("Only image- or Dockerfile-based devcontainers are supported in v1.");
+  }
+}
+function getGeneratedConfigPath(sourceConfigPath) {
+  const sourceBasename = path.basename(sourceConfigPath);
+  if (sourceBasename === "devcontainer.json") {
+    return path.join(path.dirname(sourceConfigPath), ".devcontainer.json");
+  }
+  if (sourceBasename === ".devcontainer.json") {
+    return path.join(path.dirname(sourceConfigPath), "devcontainer.json");
+  }
+  throw new UserError(`Unsupported devcontainer config filename: ${sourceConfigPath}. Expected devcontainer.json or .devcontainer.json.`);
+}
+function getLegacyGeneratedConfigPath(sourceConfigPath) {
+  return path.join(path.dirname(sourceConfigPath), LEGACY_GENERATED_CONFIG_BASENAME);
+}
+async function writeManagedConfig(generatedConfigPath, config) {
+  await mkdir(path.dirname(generatedConfigPath), { recursive: true });
+  await writeFile(generatedConfigPath, `${JSON.stringify(config, null, 2)}
+`, "utf8");
+}
+async function removeGeneratedConfig(generatedConfigPath) {
+  await rm(generatedConfigPath, { force: true });
+}
+function buildManagedConfig(baseConfig, options) {
+  const managedConfig = structuredClone(baseConfig);
+  const runArgs = withManagedContainerName(getStringArray(managedConfig.runArgs, "runArgs"), options.containerName);
+  if (!hasPublishedPort(runArgs, options.port)) {
+    runArgs.push("-p", `${options.port}:${options.port}`);
+  }
+  managedConfig.runArgs = runArgs;
+  const mounts = getStringArray(managedConfig.mounts, "mounts");
+  if (options.sshAuthSock) {
+    mounts.push(`type=bind,source=${options.sshAuthSock},target=${SSH_AUTH_SOCK_TARGET}`);
+  }
+  if (options.knownHostsPath) {
+    mounts.push(`type=bind,source=${options.knownHostsPath},target=${KNOWN_HOSTS_TARGET},readonly`);
+  }
+  managedConfig.mounts = dedupe(mounts);
+  const containerEnv = getStringRecord(managedConfig.containerEnv, "containerEnv");
+  if (options.sshAuthSock) {
+    containerEnv.SSH_AUTH_SOCK = SSH_AUTH_SOCK_TARGET;
+  }
+  managedConfig.containerEnv = containerEnv;
+  return managedConfig;
+}
+function createWorkspaceState(input) {
+  return {
+    version: STATE_VERSION,
+    workspacePath: input.workspacePath,
+    workspaceHash: hashWorkspacePath(input.workspacePath),
+    port: input.port,
+    sourceConfigPath: input.sourceConfigPath,
+    generatedConfigPath: input.generatedConfigPath,
+    labels: input.labels,
+    userDataDir: input.userDataDir,
+    lastContainerId: input.containerId,
+    updatedAt: new Date().toISOString()
+  };
+}
+async function getKnownHostsPath() {
+  const candidate = path.join(os.homedir(), ".ssh", "known_hosts");
+  try {
+    await access(candidate);
+    return candidate;
+  } catch {
+    return null;
+  }
+}
+function quoteShell(value) {
+  return `'${value.replaceAll("'", `'"'"'`)}'`;
+}
+function dedupe(values) {
+  return [...new Set(values)];
+}
+function withManagedContainerName(runArgs, containerName) {
+  const next = [];
+  for (let index = 0;index < runArgs.length; index += 1) {
+    const current = runArgs[index];
+    if (current === "--name") {
+      index += 1;
+      continue;
+    }
+    if (current.startsWith("--name=")) {
+      continue;
+    }
+    next.push(current);
+  }
+  next.push("--name", containerName);
+  return next;
+}
+function hasPublishedPort(runArgs, port) {
+  const expected = `${port}:${port}`;
+  for (let index = 0;index < runArgs.length; index += 1) {
+    const current = runArgs[index];
+    const next = runArgs[index + 1];
+    if ((current === "-p" || current === "--publish") && next === expected) {
+      return true;
+    }
+    if (current.startsWith("-p") && current.slice(2) === expected) {
+      return true;
+    }
+    if (current.startsWith("--publish=") && current.slice("--publish=".length) === expected) {
+      return true;
+    }
+  }
+  return false;
+}
+function getStringArray(value, fieldName) {
+  if (value === undefined) {
+    return [];
+  }
+  if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string")) {
+    throw new UserError(`${fieldName} must be an array of strings.`);
+  }
+  return [...value];
+}
+function getStringRecord(value, fieldName) {
+  if (value === undefined) {
+    return {};
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new UserError(`${fieldName} must be an object with string values.`);
+  }
+  const entries = Object.entries(value);
+  if (entries.some(([, entryValue]) => typeof entryValue !== "string")) {
+    throw new UserError(`${fieldName} must be an object with string values.`);
+  }
+  return Object.fromEntries(entries);
+}
+function asRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  return value;
+}
+
+// src/runtime.ts
+import { spawn } from "node:child_process";
+import { access as access2, appendFile, mkdir as mkdir2, readFile as readFile2 } from "node:fs/promises";
+import { accessSync, constants as fsConstants } from "node:fs";
+import path2 from "node:path";
+class CommandError extends Error {
+  command;
+  result;
+  constructor(command, result) {
+    super(`Command failed: ${command.join(" ")}`);
+    this.command = command;
+    this.result = result;
+    this.name = "CommandError";
+  }
+}
+function isExecutableAvailable(command) {
+  return findExecutableOnPath(command) !== null;
+}
+function buildStopManagedSshdScript() {
+  return [
+    "pids=$(ps -eo pid=,comm= | while read -r pid comm; do",
+    `  if [ "$comm" = "sshd" ]; then printf '%s\\n' "$pid"; fi`,
+    "done)",
+    'if [ -n "$pids" ]; then kill $pids; fi'
+  ].join(`
+`);
+}
+function getRunnerCredFile(remoteWorkspaceFolder) {
+  const trimmed = remoteWorkspaceFolder.endsWith("/") ? remoteWorkspaceFolder.slice(0, -1) : remoteWorkspaceFolder;
+  return `${trimmed}/${RUNNER_CRED_FILENAME}`;
+}
+function getRunnerSummaryLines(output) {
+  return output.split(/\r?\n/).map((line) => line.trimEnd()).filter((line) => /^(SSH user|SSH pass|SSH port|PermitRootLogin): /.test(line));
+}
+function formatDevcontainerProgressLine(line) {
+  const cleaned = stripAnsi(line).trim();
+  if (!cleaned) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(cleaned);
+    const text = typeof parsed.text === "string" ? stripAnsi(parsed.text).trim() : "";
+    const type = typeof parsed.type === "string" ? parsed.type : "";
+    const level = typeof parsed.level === "number" ? parsed.level : undefined;
+    if (parsed.outcome !== undefined) {
+      return null;
+    }
+    if (!text) {
+      return null;
+    }
+    if (text.startsWith("Error:")) {
+      return text;
+    }
+    if (type === "start") {
+      if (text === "Resolving Remote") {
+        return "Preparing devcontainer...";
+      }
+      if (text === "Starting container") {
+        return "Starting container...";
+      }
+      return null;
+    }
+    if (type === "raw" && text === "Container started") {
+      return "Container started.";
+    }
+    if (text.startsWith("workspace root: ")) {
+      return `Workspace: ${text.slice("workspace root: ".length)}`;
+    }
+    if (text === "No user features to update" || text === "Inspecting container" || text.startsWith("Run: ") || text.startsWith("Run in container: ") || text.startsWith("userEnvProbe") || text.startsWith("LifecycleCommandExecutionMap:") || text.startsWith("Exit code ")) {
+      return null;
+    }
+    if (level !== undefined && level >= 2) {
+      return null;
+    }
+    return text;
+  } catch {
+    return cleaned;
+  }
+}
+function requiresSshAuthSockPermissionFix(sshAuthSockSource) {
+  return sshAuthSockSource === DOCKER_DESKTOP_SSH_AUTH_SOCK_SOURCE;
+}
+function buildEnsureSshAuthSockAccessibleScript() {
+  return `if [ -S ${quoteShell(SSH_AUTH_SOCK_TARGET)} ]; then chmod 666 ${quoteShell(SSH_AUTH_SOCK_TARGET)}; fi`;
+}
+function getRunnerHostKeysDir(remoteWorkspaceFolder) {
+  const trimmed = remoteWorkspaceFolder.endsWith("/") ? remoteWorkspaceFolder.slice(0, -1) : remoteWorkspaceFolder;
+  return `${trimmed}/${RUNNER_HOST_KEYS_DIRNAME}`;
+}
+function buildRestoreRunnerHostKeysScript(remoteWorkspaceFolder) {
+  const hostKeysDir = getRunnerHostKeysDir(remoteWorkspaceFolder);
+  return [
+    `if [ -d ${quoteShell(hostKeysDir)} ]; then`,
+    "  mkdir -p /etc/ssh",
+    `  find ${quoteShell(hostKeysDir)} -maxdepth 1 -type f -name 'ssh_host_*' -exec cp {} /etc/ssh/ \\;`,
+    "  chmod 600 /etc/ssh/ssh_host_*_key 2>/dev/null || true",
+    "  chmod 644 /etc/ssh/ssh_host_*_key.pub 2>/dev/null || true",
+    "fi"
+  ].join(`
+`);
+}
+function buildPersistRunnerHostKeysScript(remoteWorkspaceFolder) {
+  const hostKeysDir = getRunnerHostKeysDir(remoteWorkspaceFolder);
+  return [
+    `mkdir -p ${quoteShell(hostKeysDir)}`,
+    `find /etc/ssh -maxdepth 1 -type f -name 'ssh_host_*' -exec cp {} ${quoteShell(hostKeysDir)}/ \\;`,
+    `chmod 700 ${quoteShell(hostKeysDir)}`,
+    `chmod 600 ${quoteShell(hostKeysDir)}/ssh_host_*_key 2>/dev/null || true`,
+    `chmod 644 ${quoteShell(hostKeysDir)}/ssh_host_*_key.pub 2>/dev/null || true`
+  ].join(`
+`);
+}
+function resolveSshAuthSockSource(input) {
+  const hostEnvSshAuthSock = input.hostEnvSshAuthSock?.trim() || undefined;
+  if (input.dockerDesktopHostServiceAvailable) {
+    return { sshAuthSock: DOCKER_DESKTOP_SSH_AUTH_SOCK_SOURCE };
+  }
+  if (hostEnvSshAuthSock && input.hostEnvSockExists) {
+    return { sshAuthSock: hostEnvSshAuthSock };
+  }
+  const detail = hostEnvSshAuthSock ? `SSH_AUTH_SOCK does not exist: ${hostEnvSshAuthSock}.` : "No usable SSH agent socket was found. Set SSH_AUTH_SOCK or use Docker Desktop host services.";
+  if (input.allowMissingSsh) {
+    return {
+      sshAuthSock: null,
+      warning: `${detail} Continuing without SSH agent sharing.`
+    };
+  }
+  throw new UserError(`${detail} Pass --allow-missing-ssh to continue without SSH agent sharing.`);
+}
+async function ensureHostEnvironment(options) {
+  if (process.platform !== "darwin" && process.platform !== "linux") {
+    throw new UserError(`Unsupported platform: ${process.platform}. macOS and Linux are supported in v1.`);
+  }
+  if (!isExecutableAvailable("docker")) {
+    throw new UserError("Docker is required but was not found in PATH.");
+  }
+  if (!isExecutableAvailable("devcontainer")) {
+    throw new UserError("Dev Container CLI is required but was not found in PATH.");
+  }
+  const hostEnvSshAuthSock = process.env.SSH_AUTH_SOCK?.trim() || undefined;
+  const hostEnvSockExists = hostEnvSshAuthSock ? await pathExists(hostEnvSshAuthSock) : false;
+  const dockerDesktopHostServiceAvailable = await hasDockerDesktopHostService();
+  return resolveSshAuthSockSource({
+    hostEnvSshAuthSock,
+    hostEnvSockExists,
+    dockerDesktopHostServiceAvailable,
+    allowMissingSsh: options.allowMissingSsh
+  });
+}
+async function ensureGeneratedConfigIgnored(workspacePath, generatedConfigPath) {
+  await ensurePathIgnored(workspacePath, generatedConfigPath);
+}
+async function ensurePathIgnored(workspacePath, absolutePath) {
+  const gitTopLevel = await tryGetGitTopLevel(workspacePath);
+  if (!gitTopLevel) {
+    return;
+  }
+  const relative = path2.relative(gitTopLevel, absolutePath);
+  if (!relative || relative.startsWith("..")) {
+    return;
+  }
+  const normalized = `/${relative.split(path2.sep).join("/")}`;
+  const excludePath = path2.join(gitTopLevel, ".git", "info", "exclude");
+  await mkdir2(path2.dirname(excludePath), { recursive: true });
+  let current = "";
+  try {
+    current = await readFile2(excludePath, "utf8");
+  } catch {
+    current = "";
+  }
+  const lines = new Set(current.split(/\r?\n/).filter(Boolean));
+  if (lines.has(normalized)) {
+    return;
+  }
+  const prefix = current.length > 0 && !current.endsWith(`
+`) ? `
+` : "";
+  await appendFile(excludePath, `${prefix}${normalized}
+`, "utf8");
+}
+async function listManagedContainers(labels) {
+  const args = ["ps", "-aq"];
+  for (const [key, value] of Object.entries(labels)) {
+    args.push("--filter", `label=${key}=${value}`);
+  }
+  const result = await execute(["docker", ...args], {
+    stdoutMode: "capture",
+    stderrMode: "capture"
+  });
+  return result.stdout.split(/\s+/).map((entry) => entry.trim()).filter(Boolean);
+}
+async function inspectContainers(containerIds) {
+  if (containerIds.length === 0) {
+    return [];
+  }
+  const result = await execute(["docker", "inspect", ...containerIds], {
+    stdoutMode: "capture",
+    stderrMode: "capture"
+  });
+  return JSON.parse(result.stdout);
+}
+async function assertPortAvailable(port, allowIfManagedContainerOwnsPort) {
+  const pids = await findListeningPids(port);
+  if (pids.length === 0) {
+    return;
+  }
+  if (allowIfManagedContainerOwnsPort) {
+    return;
+  }
+  throw new UserError(`Host port ${port} is already in use by PID(s): ${pids.join(", ")}.`);
+}
+async function removeContainers(containerIds) {
+  if (containerIds.length === 0) {
+    return;
+  }
+  await execute(["docker", "rm", "--force", ...containerIds], {
+    stdoutMode: "raw",
+    stderrMode: "raw"
+  });
+}
+async function devcontainerUp(input) {
+  await mkdir2(input.userDataDir, { recursive: true });
+  const args = [
+    "devcontainer",
+    "up",
+    "--workspace-folder",
+    input.workspacePath,
+    "--mount-workspace-git-root",
+    "false",
+    "--config",
+    input.generatedConfigPath,
+    "--user-data-folder",
+    input.userDataDir,
+    "--log-format",
+    "json"
+  ];
+  for (const [key, value] of Object.entries(input.labels)) {
+    args.push("--id-label", `${key}=${value}`);
+  }
+  const result = await execute(args, {
+    stdoutMode: "devcontainer-json",
+    stderrMode: "devcontainer-json"
+  });
+  const outcome = parseDevcontainerOutcome(result.stdout);
+  if (!outcome || outcome.outcome !== "success" || typeof outcome.containerId !== "string") {
+    throw new UserError("devcontainer up did not return a success outcome.");
+  }
+  return outcome;
+}
+async function copyKnownHosts(containerId) {
+  const script = `if [ -f ${quoteShell(KNOWN_HOSTS_TARGET)} ]; then umask 077 && mkdir -p ~/.ssh && cp ${quoteShell(KNOWN_HOSTS_TARGET)} ~/.ssh/known_hosts && chmod 600 ~/.ssh/known_hosts; fi`;
+  await devcontainerExec(containerId, script, { quiet: true });
+}
+async function stopManagedSshd(containerId) {
+  await devcontainerExec(containerId, buildStopManagedSshdScript(), { quiet: true });
+}
+async function ensureSshAuthSockAccessible(containerId) {
+  await dockerExec(containerId, buildEnsureSshAuthSockAccessibleScript(), {
+    quiet: true,
+    user: "root"
+  });
+}
+async function restoreRunnerHostKeys(containerId, remoteWorkspaceFolder) {
+  await dockerExec(containerId, buildRestoreRunnerHostKeysScript(remoteWorkspaceFolder), {
+    quiet: true,
+    user: "root"
+  });
+}
+async function startRunner(containerId, port, remoteWorkspaceFolder) {
+  const script = `curl -fsSL ${quoteShell(RUNNER_URL)} | env SSH_PORT=${quoteShell(String(port))} CRED_FILE=${quoteShell(getRunnerCredFile(remoteWorkspaceFolder))} bash`;
+  const result = await devcontainerExec(containerId, script, { quiet: true });
+  const summaryLines = getRunnerSummaryLines(result.stdout);
+  if (summaryLines.length > 0) {
+    console.log(`
+SSH server:`);
+    for (const line of summaryLines) {
+      console.log(`  ${line}`);
+    }
+  } else {
+    const output = result.stdout.trim();
+    if (output) {
+      console.log(output);
+    }
+  }
+}
+async function persistRunnerHostKeys(containerId, remoteWorkspaceFolder) {
+  await dockerExec(containerId, buildPersistRunnerHostKeysScript(remoteWorkspaceFolder), {
+    quiet: true,
+    user: "root"
+  });
+}
+async function hasDockerDesktopHostService() {
+  const result = await execute(["docker", "info", "--format", "{{.OperatingSystem}}"], {
+    stdoutMode: "capture",
+    stderrMode: "capture",
+    allowFailure: true
+  });
+  if (result.exitCode !== 0) {
+    return false;
+  }
+  return result.stdout.toLowerCase().includes("docker desktop");
+}
+async function devcontainerExec(containerId, script, options) {
+  const args = ["devcontainer", "exec", "--container-id", containerId, "sh", "-lc", script];
+  return execute(args, {
+    stdoutMode: options.quiet ? "capture" : "raw",
+    stderrMode: options.quiet ? "capture" : "raw"
+  });
+}
+async function dockerExec(containerId, script, options) {
+  const args = ["docker", "exec"];
+  if (options.user) {
+    args.push("--user", options.user);
+  }
+  args.push(containerId, "sh", "-lc", script);
+  return execute(args, {
+    stdoutMode: options.quiet ? "capture" : "raw",
+    stderrMode: options.quiet ? "capture" : "raw"
+  });
+}
+async function tryGetGitTopLevel(workspacePath) {
+  try {
+    const result = await execute(["git", "-C", workspacePath, "rev-parse", "--show-toplevel"], {
+      stdoutMode: "capture",
+      stderrMode: "capture",
+      allowFailure: true
+    });
+    if (result.exitCode !== 0) {
+      return null;
+    }
+    const trimmed = result.stdout.trim();
+    return trimmed.length > 0 ? trimmed : null;
+  } catch {
+    return null;
+  }
+}
+async function findListeningPids(port) {
+  if (isExecutableAvailable("lsof")) {
+    const result = await execute(["lsof", "-nP", `-iTCP:${port}`, "-sTCP:LISTEN", "-t"], {
+      stdoutMode: "capture",
+      stderrMode: "capture",
+      allowFailure: true
+    });
+    if (result.exitCode === 0) {
+      return result.stdout.split(/\s+/).map((entry) => entry.trim()).filter(Boolean);
+    }
+    if (result.exitCode === 1) {
+      return [];
+    }
+    throw new UserError(`Could not determine whether port ${port} is free because lsof failed with exit code ${result.exitCode}.`);
+  }
+  return [];
+}
+async function execute(command, options) {
+  const env = { ...process.env, ...options.env ?? {} };
+  for (const [key, value] of Object.entries(env)) {
+    if (value === undefined) {
+      delete env[key];
+    }
+  }
+  const subprocess = spawn(command[0], command.slice(1), {
+    cwd: options.cwd,
+    env,
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  const stdoutPromise = consumeStream(subprocess.stdout, options.stdoutMode ?? "capture", false);
+  const stderrPromise = consumeStream(subprocess.stderr, options.stderrMode ?? "capture", true);
+  const exitPromise = new Promise((resolve, reject) => {
+    subprocess.once("error", reject);
+    subprocess.once("close", (exitCode2) => {
+      resolve(exitCode2 ?? 0);
+    });
+  });
+  const [stdout, stderr, exitCode] = await Promise.all([stdoutPromise, stderrPromise, exitPromise]);
+  const result = { stdout, stderr, exitCode };
+  if (exitCode !== 0 && !options.allowFailure) {
+    throw new CommandError(command, result);
+  }
+  return result;
+}
+async function consumeStream(stream, mode, useStderr) {
+  if (!stream) {
+    return "";
+  }
+  const writer = useStderr ? process.stderr : process.stdout;
+  stream.setEncoding("utf8");
+  let captured = "";
+  let buffered = "";
+  for await (const chunk of stream) {
+    const text = typeof chunk === "string" ? chunk : String(chunk);
+    captured += text;
+    if (mode === "raw") {
+      writer.write(text);
+      continue;
+    }
+    if (mode === "capture") {
+      continue;
+    }
+    buffered += text;
+    let newlineIndex = buffered.indexOf(`
+`);
+    while (newlineIndex >= 0) {
+      const line = buffered.slice(0, newlineIndex);
+      buffered = buffered.slice(newlineIndex + 1);
+      renderDevcontainerJsonLine(line, writer);
+      newlineIndex = buffered.indexOf(`
+`);
+    }
+  }
+  if (mode === "devcontainer-json" && buffered.length > 0) {
+    renderDevcontainerJsonLine(buffered, writer);
+  }
+  return captured;
+}
+async function pathExists(targetPath) {
+  try {
+    await access2(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function findExecutableOnPath(command) {
+  if (command.includes(path2.sep)) {
+    return isExecutablePath(command) ? command : null;
+  }
+  const pathValue = process.env.PATH ?? "";
+  for (const directory of pathValue.split(path2.delimiter)) {
+    if (!directory) {
+      continue;
+    }
+    const candidate = path2.join(directory, command);
+    if (isExecutablePath(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function isExecutablePath(candidate) {
+  try {
+    accessSync(candidate, fsConstants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function renderDevcontainerJsonLine(line, writer) {
+  const formatted = formatDevcontainerProgressLine(line);
+  if (formatted) {
+    writer.write(`${formatted}
+`);
+  }
+}
+function parseDevcontainerOutcome(stdout) {
+  const lines = stdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  for (let index = lines.length - 1;index >= 0; index -= 1) {
+    try {
+      const parsed = JSON.parse(lines[index]);
+      if (typeof parsed.outcome === "string") {
+        return parsed;
+      }
+    } catch {}
+  }
+  return null;
+}
+function isCommandError(error) {
+  return error instanceof CommandError;
+}
+function formatCommandError(error) {
+  const stderr = error.result.stderr.trim();
+  const stdout = error.result.stdout.trim();
+  const details = stderr || stdout;
+  if (!details) {
+    return `${error.message} (exit ${error.result.exitCode})`;
+  }
+  return `${error.message}
+${details}`;
+}
+function stripAnsi(text) {
+  return text.replace(/\u001B\[[0-9;]*m/g, "");
+}
+function labelsForWorkspaceHash(workspaceHash) {
+  return {
+    [MANAGED_LABEL_KEY]: "true",
+    [WORKSPACE_LABEL_KEY]: workspaceHash
+  };
+}
+
+// src/cli.ts
+async function main() {
+  const parsed = parseArgs(process.argv.slice(2));
+  if (parsed.command === "help") {
+    console.log(helpText());
+    return;
+  }
+  const workspacePath = await realpath(process.cwd());
+  const state = await loadWorkspaceState(workspacePath);
+  if (parsed.command === "down") {
+    await handleDown(workspacePath, state);
+    return;
+  }
+  await handleUpLike(parsed.command, workspacePath, state, parsed.port, parsed.allowMissingSsh);
+}
+async function handleUpLike(command, workspacePath, state, explicitPort, allowMissingSsh) {
+  const environment = await ensureHostEnvironment({ allowMissingSsh });
+  const port = resolvePort(command, explicitPort, state);
+  const knownHostsPath = await getKnownHostsPath();
+  const discovered = await discoverDevcontainerConfig(workspacePath);
+  const generatedConfigPath = getGeneratedConfigPath(discovered.path);
+  const legacyGeneratedConfigPath = getLegacyGeneratedConfigPath(discovered.path);
+  const workspaceHash = hashWorkspacePath(workspacePath);
+  const labels = getManagedLabels(workspaceHash);
+  const userDataDir = getWorkspaceUserDataDir(workspacePath);
+  const containerName = getManagedContainerName(workspacePath, port);
+  const managedConfig = buildManagedConfig(discovered.config, {
+    port,
+    containerName,
+    sshAuthSock: environment.sshAuthSock,
+    knownHostsPath
+  });
+  if (environment.warning) {
+    console.warn(`Warning: ${environment.warning}`);
+  }
+  await ensureGeneratedConfigIgnored(workspacePath, generatedConfigPath);
+  await removeGeneratedConfig(legacyGeneratedConfigPath);
+  await writeManagedConfig(generatedConfigPath, managedConfig);
+  const existingContainerIds = await listManagedContainers(labels);
+  if (command === "up" && existingContainerIds.length > 1) {
+    throw new UserError("More than one managed container was found for this workspace. Run `devbox down` first.");
+  }
+  let existingInspects = [];
+  if (existingContainerIds.length > 0) {
+    existingInspects = await inspectContainers(existingContainerIds);
+  }
+  if (command === "rebuild") {
+    await removeContainers(existingContainerIds);
+    existingInspects = [];
+  } else if (existingInspects[0]) {
+    const publishedPorts = getPublishedHostPorts(existingInspects[0]);
+    if (publishedPorts.length > 0 && !publishedPorts.includes(port)) {
+      throw new UserError(`This workspace already has a managed container publishing port(s) ${publishedPorts.join(", ")}. Use \`devbox rebuild ${port}\` to change the port.`);
+    }
+  }
+  const allowCurrentPort = existingInspects.some((container) => container.State?.Running && getPublishedHostPorts(container).includes(port));
+  await assertPortAvailable(port, allowCurrentPort);
+  console.log(`Starting workspace on port ${port}...`);
+  const upResult = await devcontainerUp({
+    workspacePath,
+    generatedConfigPath,
+    userDataDir,
+    labels
+  });
+  const remoteWorkspaceFolder = upResult.remoteWorkspaceFolder ?? getDefaultRemoteWorkspaceFolder(workspacePath);
+  console.log("Configuring SSH access inside the devcontainer...");
+  await ensurePathIgnored(workspacePath, path3.join(workspacePath, RUNNER_HOST_KEYS_DIRNAME));
+  if (requiresSshAuthSockPermissionFix(environment.sshAuthSock)) {
+    console.log("Making the forwarded SSH agent socket accessible to the container user...");
+    await ensureSshAuthSockAccessible(upResult.containerId);
+  }
+  await copyKnownHosts(upResult.containerId);
+  await stopManagedSshd(upResult.containerId);
+  await restoreRunnerHostKeys(upResult.containerId, remoteWorkspaceFolder);
+  console.log("Installing and starting the SSH server inside the container (first run can take a bit)...");
+  await startRunner(upResult.containerId, port, remoteWorkspaceFolder);
+  console.log("Saving SSH server state for future runs...");
+  await persistRunnerHostKeys(upResult.containerId, remoteWorkspaceFolder);
+  await saveWorkspaceState(createWorkspaceState({
+    workspacePath,
+    port,
+    sourceConfigPath: discovered.path,
+    generatedConfigPath,
+    userDataDir,
+    labels,
+    containerId: upResult.containerId
+  }));
+  console.log(`
+Ready. ${upResult.containerId.slice(0, 12)} is available on port ${port}.`);
+  if (!knownHostsPath) {
+    console.log("Host known_hosts was not found, so only SSH agent sharing was configured.");
+  }
+}
+async function handleDown(workspacePath, state) {
+  if (!isExecutableAvailable("docker")) {
+    throw new UserError("Docker is required but was not found in PATH.");
+  }
+  const labels = labelsForWorkspaceHash(hashWorkspacePath(workspacePath));
+  const containerIds = await listManagedContainers(labels);
+  await removeContainers(containerIds);
+  const generatedConfigPaths = new Set;
+  if (state?.generatedConfigPath) {
+    generatedConfigPaths.add(state.generatedConfigPath);
+  }
+  try {
+    const discovered = await discoverDevcontainerConfig(workspacePath);
+    generatedConfigPaths.add(getGeneratedConfigPath(discovered.path));
+    generatedConfigPaths.add(getLegacyGeneratedConfigPath(discovered.path));
+  } catch {}
+  for (const generatedConfigPath of generatedConfigPaths) {
+    await removeGeneratedConfig(generatedConfigPath);
+  }
+  await deleteWorkspaceState(workspacePath);
+  if (containerIds.length === 0) {
+    console.log("No managed container was running for this workspace.");
+    return;
+  }
+  console.log(`Removed ${containerIds.length} managed container(s). Workspace-mounted SSH credentials and host keys were preserved.`);
+}
+function getPublishedHostPorts(container) {
+  const ports = container.NetworkSettings?.Ports ?? {};
+  const values = new Set;
+  for (const bindings of Object.values(ports)) {
+    if (!bindings) {
+      continue;
+    }
+    for (const binding of bindings) {
+      if (!binding?.HostPort) {
+        continue;
+      }
+      const parsed = Number(binding.HostPort);
+      if (Number.isInteger(parsed)) {
+        values.add(parsed);
+      }
+    }
+  }
+  return [...values];
+}
+main().catch((error) => {
+  if (error instanceof UserError) {
+    console.error(`Error: ${error.message}`);
+    process.exit(1);
+  }
+  if (isCommandError(error)) {
+    console.error(`Error: ${formatCommandError(error)}`);
+    process.exit(error.result.exitCode || 1);
+  }
+  console.error(error);
+  process.exit(1);
+});