codex-webstrapper 0.1.0 → 0.1.5

package/README.md

@@ -75,6 +75,8 @@ This project provides near-parity by emulation/bridging, not by removing those d
 
 ```bash
 codex-webstrap [--port <n>] [--bind <ip>] [--open] [--token-file <path>] [--codex-app <path>]
+codex-webstrapper [--port <n>] [--bind <ip>] [--open] [--token-file <path>] [--codex-app <path>]
+codex-webstrapper open [--port <n>] [--bind <ip>] [--token-file <path>] [--copy]
 ```
 
 ### Environment Overrides
@@ -112,7 +114,12 @@ codex-webstrap [--port <n>] [--bind <ip>] [--open] [--token-file <path>] [--code
 - macOS
 - Node.js 20+
 - Installed Codex app bundle at `/Applications/Codex.app` (or pass `--codex-app`)
-- `codex` CLI available in `PATH` (or set `CODEX_CLI_PATH`)
+
+By default, webstrapper runs the app-server via the bundled desktop CLI at:
+- `/Applications/Codex.app/Contents/Resources/codex`
+
+Optional override:
+- `CODEX_CLI_PATH=/custom/codex`
 
 ### Install
 
@@ -131,7 +138,7 @@ npm install -g codex-webstrapper
 With global install:
 
 ```bash
-codex-webstrap --port 8080 --bind 127.0.0.1
+codex-webstrapper --port 8080 --bind 127.0.0.1
 ```
 
 From local checkout:
@@ -143,7 +150,19 @@ From local checkout:
 Optional auto-open:
 
 ```bash
-codex-webstrap --open
+codex-webstrapper --open
+```
+
+Generate/open the full auth URL from your persisted token:
+
+```bash
+codex-webstrapper open
+```
+
+Copy the full auth URL (including token) to macOS clipboard:
+
+```bash
+codex-webstrapper open --copy
 ```
 
 ## Authentication Model
@@ -155,6 +174,12 @@ codex-webstrap --open
 open "http://127.0.0.1:8080/__webstrapper/auth?token=$(cat ~/.codex-webstrap/token)"
 ```
 
+Or use the helper command:
+
+```bash
+codex-webstrapper open
+```
+
 3. Server sets `cw_session` cookie (`HttpOnly`, `SameSite=Lax`, scoped to `/`).
 4. UI and bridge endpoints require a valid session cookie.
 
@@ -232,7 +257,7 @@ Codex setup-script compatible command:
 - Codex app not found
   - Pass `--codex-app /path/to/Codex.app`.
 - `codex` CLI spawn failures
-  - Ensure `codex` is on `PATH` or set `CODEX_CLI_PATH`.
+  - Ensure the bundled CLI exists in your Codex app install, or set `CODEX_CLI_PATH`.
 
 ## License
 

package/bin/codex-webstrap.sh

@@ -1,7 +1,14 @@
 #!/usr/bin/env bash
 set -euo pipefail
 
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+SOURCE_PATH="${BASH_SOURCE[0]}"
+while [[ -L "$SOURCE_PATH" ]]; do
+  SOURCE_DIR="$(cd -P "$(dirname "$SOURCE_PATH")" && pwd)"
+  SOURCE_PATH="$(readlink "$SOURCE_PATH")"
+  [[ "$SOURCE_PATH" != /* ]] && SOURCE_PATH="$SOURCE_DIR/$SOURCE_PATH"
+done
+
+SCRIPT_DIR="$(cd -P "$(dirname "$SOURCE_PATH")" && pwd)"
 ROOT_DIR="$(cd "${SCRIPT_DIR}/.." && pwd)"
 
 PORT="${CODEX_WEBSTRAP_PORT:-8080}"
@@ -10,40 +17,89 @@ OPEN_FLAG="0"
 TOKEN_FILE="${CODEX_WEBSTRAP_TOKEN_FILE:-}"
 CODEX_APP="${CODEX_WEBSTRAP_CODEX_APP:-}"
 INTERNAL_WS_PORT="${CODEX_WEBSTRAP_INTERNAL_WS_PORT:-38080}"
+COPY_FLAG="0"
+COMMAND="serve"
+
+DEFAULT_TOKEN_FILE="${HOME}/.codex-webstrap/token"
+if [[ -z "$TOKEN_FILE" ]]; then
+  TOKEN_FILE="$DEFAULT_TOKEN_FILE"
+fi
+
+print_usage() {
+  cat <<USAGE
+Usage:
+  $(basename "$0") [--port <n>] [--bind <ip>] [--open] [--token-file <path>] [--codex-app <path>]
+  $(basename "$0") open [--port <n>] [--bind <ip>] [--token-file <path>] [--copy]
+
+Commands:
+  open              Build the full auth URL and open it in the browser.
+
+Options for open:
+  --copy            Copy full auth URL to clipboard with pbcopy instead of launching browser.
+
+Env overrides:
+  CODEX_WEBSTRAP_PORT
+  CODEX_WEBSTRAP_BIND
+  CODEX_WEBSTRAP_TOKEN_FILE
+  CODEX_WEBSTRAP_CODEX_APP
+  CODEX_WEBSTRAP_INTERNAL_WS_PORT
+USAGE
+}
+
+require_value() {
+  local flag="$1"
+  local value="${2:-}"
+  if [[ -z "$value" ]]; then
+    echo "Missing value for ${flag}" >&2
+    exit 1
+  fi
+}
+
+if [[ $# -gt 0 ]]; then
+  case "$1" in
+    open)
+      COMMAND="open"
+      shift
+      ;;
+    --help|-h|help)
+      print_usage
+      exit 0
+      ;;
+  esac
+fi
 
 while [[ $# -gt 0 ]]; do
   case "$1" in
     --port)
+      require_value "$1" "${2:-}"
       PORT="$2"
       shift 2
       ;;
     --bind)
+      require_value "$1" "${2:-}"
       BIND="$2"
       shift 2
       ;;
-    --open)
-      OPEN_FLAG="1"
-      shift
-      ;;
     --token-file)
+      require_value "$1" "${2:-}"
       TOKEN_FILE="$2"
       shift 2
       ;;
+    --copy)
+      COPY_FLAG="1"
+      shift
+      ;;
+    --open)
+      OPEN_FLAG="1"
+      shift
+      ;;
     --codex-app)
+      require_value "$1" "${2:-}"
       CODEX_APP="$2"
       shift 2
       ;;
-    --help|-h)
-      cat <<USAGE
-Usage: $(basename "$0") [--port <n>] [--bind <ip>] [--open] [--token-file <path>] [--codex-app <path>]
-
-Env overrides:
-  CODEX_WEBSTRAP_PORT
-  CODEX_WEBSTRAP_BIND
-  CODEX_WEBSTRAP_TOKEN_FILE
-  CODEX_WEBSTRAP_CODEX_APP
-  CODEX_WEBSTRAP_INTERNAL_WS_PORT
-USAGE
+    --help|-h|help)
+      print_usage
       exit 0
       ;;
     *)
@@ -53,6 +109,42 @@ USAGE
   esac
 done
 
+if [[ "$COMMAND" != "open" && "$COPY_FLAG" == "1" ]]; then
+  echo "--copy can only be used with the 'open' command" >&2
+  exit 1
+fi
+
+if [[ "$COMMAND" == "open" ]]; then
+  if [[ ! -f "$TOKEN_FILE" ]]; then
+    echo "Token file not found: $TOKEN_FILE" >&2
+    exit 1
+  fi
+
+  TOKEN="$(tr -d '\r\n' < "$TOKEN_FILE")"
+  if [[ -z "$TOKEN" ]]; then
+    echo "Token file is empty: $TOKEN_FILE" >&2
+    exit 1
+  fi
+
+  ENCODED_TOKEN="$(node -e 'process.stdout.write(encodeURIComponent(process.argv[1] || ""))' "$TOKEN")"
+  AUTH_URL="http://${BIND}:${PORT}/__webstrapper/auth?token=${ENCODED_TOKEN}"
+
+  if [[ "$COPY_FLAG" == "1" ]]; then
+    if ! command -v pbcopy >/dev/null 2>&1; then
+      echo "pbcopy not found in PATH" >&2
+      exit 1
+    fi
+    printf '%s' "$AUTH_URL" | pbcopy
+    printf 'Copied auth URL to clipboard.\n'
+    printf '%s\n' "$AUTH_URL"
+  else
+    open "$AUTH_URL"
+    printf 'Opened auth URL in browser.\n'
+    printf '%s\n' "$AUTH_URL"
+  fi
+  exit 0
+fi
+
 export CODEX_WEBSTRAP_PORT="$PORT"
 export CODEX_WEBSTRAP_BIND="$BIND"
 export CODEX_WEBSTRAP_TOKEN_FILE="$TOKEN_FILE"

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "codex-webstrapper",
-  "version": "0.1.0",
+  "version": "0.1.5",
   "type": "module",
   "description": "Web wrapper for Codex desktop assets with bridge + token auth",
   "license": "MIT",
   "bin": {
-    "codex-webstrap": "./bin/codex-webstrap.sh"
+    "codex-webstrap": "./bin/codex-webstrap.sh",
+    "codex-webstrapper": "./bin/codex-webstrap.sh"
   },
   "files": [
     "bin/",

package/src/assets.mjs

@@ -37,7 +37,8 @@ export function resolveCodexAppPaths(explicitCodexAppPath) {
   const resourcesPath = path.join(appPath, "Contents", "Resources");
   const asarPath = path.join(resourcesPath, "app.asar");
   const infoPlistPath = path.join(appPath, "Contents", "Info.plist");
-  return { appPath, resourcesPath, asarPath, infoPlistPath };
+  const codexCliPath = path.join(resourcesPath, "codex");
+  return { appPath, resourcesPath, asarPath, infoPlistPath, codexCliPath };
 }
 
 export async function ensureCodexAppExists(paths) {

package/src/message-router.mjs

@@ -880,6 +880,7 @@ export class MessageRouter {
       }
 
       let payload = {};
+      let status = 200;
       switch (endpoint) {
         case "get-global-state": {
           const key = params?.key;
@@ -1018,7 +1019,7 @@ export class MessageRouter {
           };
           break;
         case "local-environments":
-          payload = [];
+          payload = await this._resolveLocalEnvironments(params);
           break;
         case "has-custom-cli-executable":
           payload = { hasCustomCliExecutable: false };
@@ -1050,6 +1051,11 @@ export class MessageRouter {
           };
           break;
         }
+        case "git-push": {
+          payload = await this._handleGitPush(params);
+          status = payload.ok ? 200 : 500;
+          break;
+        }
         case "git-merge-base": {
           const gitRoot = typeof params?.gitRoot === "string" && params.gitRoot.length > 0
             ? params.gitRoot
@@ -1115,7 +1121,7 @@ export class MessageRouter {
       this._sendFetchJson(ws, {
         requestId,
         url: message.url,
-        status: 200,
+        status,
         payload
       });
       return true;
@@ -1333,6 +1339,55 @@ export class MessageRouter {
     };
   }
 
+  async _handleGitPush(params) {
+    const cwd = typeof params?.cwd === "string" && params.cwd.length > 0
+      ? params.cwd
+      : process.cwd();
+    const remote = typeof params?.remote === "string" && params.remote.trim().length > 0
+      ? params.remote.trim()
+      : null;
+    const branch = typeof params?.branch === "string" && params.branch.trim().length > 0
+      ? params.branch.trim()
+      : null;
+
+    const args = ["-C", cwd, "push"];
+    if (params?.force === true || params?.forceWithLease === true) {
+      args.push("--force-with-lease");
+    }
+    if (params?.setUpstream === true) {
+      args.push("--set-upstream");
+    }
+    if (remote) {
+      args.push(remote);
+    }
+    if (branch) {
+      args.push(branch);
+    }
+
+    const result = await this._runCommand("git", args, {
+      cwd,
+      timeoutMs: 120_000,
+      allowNonZero: true
+    });
+
+    if (result.ok) {
+      return {
+        ok: true,
+        code: result.code,
+        stdout: result.stdout || "",
+        stderr: result.stderr || ""
+      };
+    }
+
+    return {
+      ok: false,
+      code: result.code,
+      error: result.error || result.stderr || "git push failed",
+      stdout: result.stdout || "",
+      stderr: result.stderr || ""
+    };
+  }
+
   async _runCommand(command, args, { timeoutMs = 5_000, allowNonZero = false, cwd = process.cwd() } = {}) {
     return new Promise((resolve) => {
       const child = spawn(command, args, {
@@ -1471,6 +1526,128 @@ export class MessageRouter {
     return trimmed.replace(/\/+$/, "");
   }
 
+  async _resolveLocalEnvironments(params) {
+    const workspaceRoot = this._resolveLocalEnvironmentWorkspaceRoot(params?.workspaceRoot);
+    if (!workspaceRoot) {
+      return { environments: [] };
+    }
+
+    const configDir = path.join(workspaceRoot, ".codex", "environments");
+    let entries;
+    try {
+      entries = await fs.readdir(configDir, { withFileTypes: true });
+    } catch {
+      return { environments: [] };
+    }
+
+    const configFiles = entries
+      .filter((entry) => entry.isFile() && /^environment(?:-\d+)?\.toml$/i.test(entry.name))
+      .map((entry) => entry.name)
+      .sort((left, right) => {
+        const leftIsDefault = left.toLowerCase() === "environment.toml";
+        const rightIsDefault = right.toLowerCase() === "environment.toml";
+        if (leftIsDefault && !rightIsDefault) {
+          return -1;
+        }
+        if (!leftIsDefault && rightIsDefault) {
+          return 1;
+        }
+        return left.localeCompare(right, undefined, { numeric: true, sensitivity: "base" });
+      });
+
+    if (configFiles.length === 0) {
+      return { environments: [] };
+    }
+
+    const environments = await Promise.all(configFiles.map(async (fileName) => {
+      const configPath = path.join(configDir, fileName);
+      try {
+        const raw = await fs.readFile(configPath, "utf8");
+        const environment = this._parseLocalEnvironmentConfig(raw, configPath);
+        return {
+          type: "success",
+          configPath,
+          environment
+        };
+      } catch (error) {
+        return {
+          type: "error",
+          configPath,
+          error: {
+            message: toErrorMessage(error)
+          }
+        };
+      }
+    }));
+
+    return { environments };
+  }
+
+  _resolveLocalEnvironmentWorkspaceRoot(root) {
+    const normalized = this._normalizeWorkspaceRoot(root);
+    if (normalized) {
+      return path.resolve(normalized);
+    }
+
+    const activeRoot = this._normalizeWorkspaceRoot(this.activeWorkspaceRoots?.[0]);
+    if (activeRoot) {
+      return path.resolve(activeRoot);
+    }
+
+    return this.defaultWorkspaceRoot ? path.resolve(this.defaultWorkspaceRoot) : null;
+  }
+
+  _parseLocalEnvironmentConfig(raw, configPath) {
+    const name = this._parseTomlString(raw, "name") || path.basename(configPath, ".toml");
+    const versionRaw = this._parseTomlNumber(raw, "version");
+    const setupScript = this._parseTomlStringInSection(raw, "setup", "script") || "";
+
+    return {
+      version: Number.isInteger(versionRaw) ? versionRaw : 1,
+      name,
+      setup: {
+        script: setupScript
+      },
+      actions: []
+    };
+  }
+
+  _parseTomlString(raw, key) {
+    const escapedKey = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const pattern = new RegExp(`^\\s*${escapedKey}\\s*=\\s*(?:"([^"]*)"|'([^']*)')\\s*$`, "m");
+    const match = raw.match(pattern);
+    if (!match) {
+      return null;
+    }
+    return match[1] ?? match[2] ?? null;
+  }
+
+  _parseTomlNumber(raw, key) {
+    const escapedKey = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const pattern = new RegExp(`^\\s*${escapedKey}\\s*=\\s*(-?\\d+)\\s*$`, "m");
+    const match = raw.match(pattern);
+    if (!match) {
+      return null;
+    }
+    const value = Number.parseInt(match[1], 10);
+    return Number.isNaN(value) ? null : value;
+  }
+
+  _parseTomlStringInSection(raw, sectionName, key) {
+    const escapedSection = sectionName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const sectionPattern = new RegExp(`^\\s*\\[${escapedSection}\\]\\s*$`, "m");
+    const sectionMatch = sectionPattern.exec(raw);
+    if (!sectionMatch) {
+      return null;
+    }
+
+    const sectionStart = sectionMatch.index + sectionMatch[0].length;
+    const rest = raw.slice(sectionStart);
+    const nextSectionMatch = rest.match(/^\s*\[[^\]]+\]\s*$/m);
+    const sectionBody = nextSectionMatch ? rest.slice(0, nextSectionMatch.index) : rest;
+    return this._parseTomlString(sectionBody, key);
+  }
+
   _loadPersistedGlobalState() {
     if (!this.globalStatePath) {
       return;

package/src/server.mjs

@@ -148,8 +148,20 @@ async function main() {
   });
   const patchedIndexHtml = await buildPatchedIndexHtml(assetBundle.indexPath);
 
+  let codexCliPath = process.env.CODEX_CLI_PATH || codexPaths.codexCliPath;
+  if (!process.env.CODEX_CLI_PATH) {
+    const bundledCliExists = await fs.access(codexPaths.codexCliPath).then(() => true).catch(() => false);
+    if (!bundledCliExists) {
+      codexCliPath = "codex";
+      logger.warn("Bundled Codex CLI not found, falling back to PATH", {
+        bundledCliPath: codexPaths.codexCliPath
+      });
+    }
+  }
+
   const appServer = new AppServerManager({
     internalPort: config.internalWsPort,
+    codexCliPath,
     logger: createLogger("app-server")
   });