@pmate/cli 0.21.3 → 0.21.5

package/dist/index.js

@@ -9435,8 +9435,8 @@ __export(index_exports, {
   parseCommandArgs: () => parseCommandArgs
 });
 module.exports = __toCommonJS(index_exports);
-var import_node_fs18 = require("fs");
-var import_node_path23 = __toESM(require("path"));
+var import_node_fs19 = require("fs");
+var import_node_path24 = __toESM(require("path"));
 var import_chalk4 = __toESM(require("chalk"));
 
 // src/cli.ts
@@ -11639,8 +11639,225 @@ function formatEnvValue(value) {
   return value;
 }
 
-// src/commands/PrCommandHandler.ts
+// src/commands/PrepareDevCommandHandler.ts
+var import_node_fs6 = require("fs");
+var import_promises2 = require("fs/promises");
+var import_node_os3 = __toESM(require("os"));
+var import_node_path10 = __toESM(require("path"));
 var import_node_child_process5 = require("child_process");
+var import_node_util = require("util");
+var execFileAsync = (0, import_node_util.promisify)(import_node_child_process5.execFile);
+var LOCK_FILE_NAME = ".pmate.lock";
+var PrepareDevCommandHandler = class {
+  async handle(args) {
+    if (args.type !== "prepare-dev" /* PrepareDev */) {
+      throw new Error("Unsupported command for PrepareDevCommandHandler");
+    }
+    const envRoot = this.resolveRoot(args.envRoot, ["dev", "pmate-envs"]);
+    const baseRoot = this.resolveRoot(args.baseRoot, ["dev", "pmate"]);
+    if (args.action === "open") {
+      const result2 = await this.openEnvironment(args.repo, args.note, envRoot, baseRoot);
+      this.renderOpen(result2, args.json);
+      return result2;
+    }
+    const result = await this.closeEnvironment(args.repo, args.envIndex, envRoot);
+    this.renderClose(result, args.json);
+    return result;
+  }
+  async openEnvironment(repo, note, envRoot, baseRoot) {
+    await (0, import_promises2.mkdir)(envRoot, { recursive: true });
+    const baseRepoPath = import_node_path10.default.join(baseRoot, repo);
+    if (!await this.pathExists(baseRepoPath)) {
+      throw new Error(`Base repo not found: ${baseRepoPath}`);
+    }
+    const baseOrigin = await this.getGitOutput(baseRepoPath, ["remote", "get-url", "origin"]);
+    if (this.isLocalOrigin(baseOrigin)) {
+      throw new Error(
+        `Base repo origin must be a remote origin, got local origin: ${baseOrigin}`
+      );
+    }
+    for (let envIndex = 0; envIndex < 1e3; envIndex += 1) {
+      const envPath = import_node_path10.default.join(envRoot, `${repo}-${envIndex}`);
+      const lockPath = import_node_path10.default.join(envPath, LOCK_FILE_NAME);
+      if (!await this.pathExists(envPath)) {
+        await this.runGit(["clone", baseOrigin, envPath], envRoot);
+        await this.ensureMainBranch(envPath);
+        await this.writeLock(lockPath, repo, envIndex, envPath, baseOrigin, note);
+        return {
+          action: "open",
+          repo,
+          envIndex,
+          envPath,
+          lockPath,
+          origin: baseOrigin,
+          note,
+          created: true
+        };
+      }
+      if (!await this.pathExists(import_node_path10.default.join(envPath, ".git"))) {
+        continue;
+      }
+      if (await this.pathExists(lockPath)) {
+        continue;
+      }
+      const envOrigin = await this.safeGitOutput(envPath, ["remote", "get-url", "origin"]);
+      if (!envOrigin || envOrigin !== baseOrigin || this.isLocalOrigin(envOrigin)) {
+        continue;
+      }
+      const branch = await this.safeGitOutput(envPath, ["branch", "--show-current"]);
+      if (branch !== "main") {
+        continue;
+      }
+      if (await this.hasUncommittedChanges(envPath)) {
+        continue;
+      }
+      try {
+        await this.writeLock(lockPath, repo, envIndex, envPath, envOrigin, note);
+      } catch (error) {
+        if (this.isAlreadyExistsError(error)) {
+          continue;
+        }
+        throw error;
+      }
+      return {
+        action: "open",
+        repo,
+        envIndex,
+        envPath,
+        lockPath,
+        origin: envOrigin,
+        note,
+        created: false
+      };
+    }
+    throw new Error(`No available dev environment found for ${repo} under ${envRoot}`);
+  }
+  async closeEnvironment(repo, envIndex, envRoot) {
+    const envPath = import_node_path10.default.join(envRoot, `${repo}-${envIndex}`);
+    const lockPath = import_node_path10.default.join(envPath, LOCK_FILE_NAME);
+    if (!await this.pathExists(envPath) || !await this.pathExists(import_node_path10.default.join(envPath, ".git"))) {
+      throw new Error(`Dev environment not found: ${envPath}`);
+    }
+    const hasChanges = await this.hasUncommittedChanges(envPath);
+    if (hasChanges) {
+      throw new Error(
+        `Cannot close ${repo}-${envIndex}: local changes detected. Commit or clean the worktree first.`
+      );
+    }
+    const removedLock = await this.removeLock(lockPath);
+    return {
+      action: "close",
+      repo,
+      envIndex,
+      envPath,
+      lockPath,
+      removedLock
+    };
+  }
+  resolveRoot(input, fallbackSegments) {
+    if (input) {
+      return import_node_path10.default.resolve(input);
+    }
+    return import_node_path10.default.join(import_node_os3.default.homedir(), ...fallbackSegments);
+  }
+  async ensureMainBranch(cwd) {
+    const branch = await this.getGitOutput(cwd, ["branch", "--show-current"]);
+    if (branch !== "main") {
+      throw new Error(`Expected ${cwd} to be on main, got ${branch || "(detached)"}`);
+    }
+  }
+  async hasUncommittedChanges(cwd) {
+    const status = await this.getGitOutput(cwd, ["status", "--porcelain"]);
+    if (!status) {
+      return false;
+    }
+    const meaningfulLines = status.split("\n").map((line) => line.trimEnd()).filter(Boolean).filter((line) => {
+      const relativePath = line.slice(3).trim();
+      return relativePath !== LOCK_FILE_NAME;
+    });
+    return meaningfulLines.length > 0;
+  }
+  async getGitOutput(cwd, args) {
+    const { stdout } = await execFileAsync("git", args, { cwd });
+    return stdout.trim();
+  }
+  async safeGitOutput(cwd, args) {
+    try {
+      return await this.getGitOutput(cwd, args);
+    } catch {
+      return "";
+    }
+  }
+  async runGit(args, cwd) {
+    await execFileAsync("git", args, { cwd });
+  }
+  async pathExists(targetPath) {
+    try {
+      await (0, import_promises2.access)(targetPath, import_node_fs6.constants.F_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async writeLock(lockPath, repo, envIndex, envPath, origin, note) {
+    const payload = {
+      repo,
+      envIndex,
+      envPath,
+      origin,
+      note,
+      openedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await (0, import_promises2.writeFile)(lockPath, `${JSON.stringify(payload, null, 2)}
+`, {
+      encoding: "utf8",
+      flag: "wx"
+    });
+  }
+  async removeLock(lockPath) {
+    if (!await this.pathExists(lockPath)) {
+      return false;
+    }
+    await (0, import_promises2.rm)(lockPath, { force: true });
+    return true;
+  }
+  isLocalOrigin(origin) {
+    return origin.startsWith("/") || origin.startsWith("./") || origin.startsWith("../") || origin.startsWith("file://");
+  }
+  isAlreadyExistsError(error) {
+    return Boolean(
+      error && typeof error === "object" && "code" in error && error.code === "EEXIST"
+    );
+  }
+  renderOpen(result, asJson) {
+    if (asJson) {
+      ui.plain(JSON.stringify(result, null, 2));
+      return;
+    }
+    ui.success(
+      `${result.repo} env ready: ${result.envPath}${result.created ? " (cloned)" : ""}`,
+      {
+        env: `${result.repo}-${result.envIndex}`,
+        path: result.envPath,
+        origin: result.origin,
+        lock: result.lockPath
+      }
+    );
+  }
+  renderClose(result, asJson) {
+    if (asJson) {
+      ui.plain(JSON.stringify(result, null, 2));
+      return;
+    }
+    ui.success(`Closed ${result.repo}-${result.envIndex}`, {
+      path: result.envPath,
+      lockRemoved: result.removedLock
+    });
+  }
+};
+
+// src/commands/PrCommandHandler.ts
+var import_node_child_process6 = require("child_process");
 var PrCommandHandler = class {
   constructor(cwd = process.cwd()) {
     this.cwd = cwd;
@@ -12112,7 +12329,7 @@ ${lines}`;
   }
   run(command, args, quietError = false, env, cwd) {
     return new Promise((resolve, reject) => {
-      const child = (0, import_node_child_process5.spawn)(command, args, {
+      const child = (0, import_node_child_process6.spawn)(command, args, {
         stdio: quietError ? "ignore" : "inherit",
         env: env ?? process.env,
         cwd: cwd ?? this.cwd
@@ -12131,7 +12348,7 @@ ${lines}`;
   }
   runCapture(command, args, allowFailure = false, env, cwd) {
     return new Promise((resolve, reject) => {
-      const child = (0, import_node_child_process5.spawn)(command, args, {
+      const child = (0, import_node_child_process6.spawn)(command, args, {
         stdio: ["ignore", "pipe", "pipe"],
         env: env ?? process.env,
         cwd: cwd ?? this.cwd
@@ -12272,8 +12489,8 @@ var CommitCommandHandler = class {
 };
 
 // src/commands/SummaryCommandHandler.ts
-var import_node_child_process6 = require("child_process");
-var import_node_path10 = __toESM(require("path"));
+var import_node_child_process7 = require("child_process");
+var import_node_path11 = __toESM(require("path"));
 var SummaryCommandHandler = class {
   async handle(args) {
     const cwd = this.resolveCwd(args.cwd);
@@ -12381,7 +12598,7 @@ var SummaryCommandHandler = class {
   }
   run(command, args, quietError = false, env, cwd) {
     return new Promise((resolve, reject) => {
-      const child = (0, import_node_child_process6.spawn)(command, args, {
+      const child = (0, import_node_child_process7.spawn)(command, args, {
         stdio: quietError ? "ignore" : "inherit",
         env: env ?? process.env,
         cwd
@@ -12400,7 +12617,7 @@ var SummaryCommandHandler = class {
   }
   runCapture(command, args, allowFailure = false, env, cwd) {
     return new Promise((resolve, reject) => {
-      const child = (0, import_node_child_process6.spawn)(command, args, {
+      const child = (0, import_node_child_process7.spawn)(command, args, {
         stdio: ["ignore", "pipe", "pipe"],
         env: env ?? process.env,
         cwd
@@ -12458,7 +12675,7 @@ var SummaryCommandHandler = class {
     return this.runCapture("gh", args, allowFailure, await this.getGhEnv(cwd), cwd);
   }
   resolveCwd(value) {
-    return value ? import_node_path10.default.resolve(process.cwd(), value) : process.cwd();
+    return value ? import_node_path11.default.resolve(process.cwd(), value) : process.cwd();
   }
 };
 function truncate2(value, limit) {
@@ -12470,11 +12687,11 @@ function truncate2(value, limit) {
 }
 
 // src/commands/LinearCommandHandler.ts
-var import_node_child_process7 = require("child_process");
-var import_node_fs6 = require("fs");
-var import_node_os3 = __toESM(require("os"));
-var import_node_path11 = __toESM(require("path"));
-var import_promises2 = require("readline/promises");
+var import_node_child_process8 = require("child_process");
+var import_node_fs7 = require("fs");
+var import_node_os4 = __toESM(require("os"));
+var import_node_path12 = __toESM(require("path"));
+var import_promises3 = require("readline/promises");
 var import_openai = __toESM(require("openai"));
 var import_sdk = require("@linear/sdk");
 var ISSUE_SUMMARY_FIELDS = `
@@ -13325,7 +13542,7 @@ var LinearCommandHandler = class {
         return accounts[index];
       }
     }
-    const rl = (0, import_promises2.createInterface)({
+    const rl = (0, import_promises3.createInterface)({
       input: process.stdin,
       output: process.stdout
     });
@@ -13357,15 +13574,15 @@ var LinearCommandHandler = class {
     }
   }
   getLinearSelectionPath() {
-    return import_node_path11.default.join(import_node_os3.default.homedir(), ".pmate", "linear-selection.json");
+    return import_node_path12.default.join(import_node_os4.default.homedir(), ".pmate", "linear-selection.json");
   }
   readCachedLinearSelection(cwd) {
     const selectionPath = this.getLinearSelectionPath();
-    if (!(0, import_node_fs6.existsSync)(selectionPath)) {
+    if (!(0, import_node_fs7.existsSync)(selectionPath)) {
       return void 0;
     }
     try {
-      const raw = (0, import_node_fs6.readFileSync)(selectionPath, "utf8").trim();
+      const raw = (0, import_node_fs7.readFileSync)(selectionPath, "utf8").trim();
       if (!raw) return void 0;
       const parsed = JSON.parse(raw);
       const value = parsed[cwd];
@@ -13376,12 +13593,12 @@ var LinearCommandHandler = class {
   }
   writeCachedLinearSelection(cwd, title) {
     const selectionPath = this.getLinearSelectionPath();
-    const dir = import_node_path11.default.dirname(selectionPath);
-    (0, import_node_fs6.mkdirSync)(dir, { recursive: true });
+    const dir = import_node_path12.default.dirname(selectionPath);
+    (0, import_node_fs7.mkdirSync)(dir, { recursive: true });
     let data = {};
-    if ((0, import_node_fs6.existsSync)(selectionPath)) {
+    if ((0, import_node_fs7.existsSync)(selectionPath)) {
       try {
-        const raw = (0, import_node_fs6.readFileSync)(selectionPath, "utf8").trim();
+        const raw = (0, import_node_fs7.readFileSync)(selectionPath, "utf8").trim();
         if (raw) {
           data = JSON.parse(raw);
         }
@@ -13390,7 +13607,7 @@ var LinearCommandHandler = class {
       }
     }
     data[cwd] = title;
-    (0, import_node_fs6.writeFileSync)(selectionPath, `${JSON.stringify(data, null, 2)}
+    (0, import_node_fs7.writeFileSync)(selectionPath, `${JSON.stringify(data, null, 2)}
 `, "utf8");
   }
   async lookupIssue(client, issueRef) {
@@ -13491,7 +13708,7 @@ var LinearCommandHandler = class {
     ui.info(issue.description?.trim() ? issue.description : "  (no description)");
   }
   async collectReplInput() {
-    const rl = (0, import_promises2.createInterface)({
+    const rl = (0, import_promises3.createInterface)({
       input: process.stdin,
       output: process.stdout
     });
@@ -13551,7 +13768,7 @@ var LinearCommandHandler = class {
     } else {
       ui.info("Copy a screenshot to your clipboard, then press Enter.");
     }
-    const rl = (0, import_promises2.createInterface)({
+    const rl = (0, import_promises3.createInterface)({
       input: process.stdin,
       output: process.stdout
     });
@@ -13567,14 +13784,14 @@ var LinearCommandHandler = class {
     if (process.platform !== "darwin") {
       throw new Error("Screenshot capture only supports macOS.");
     }
-    const dir = await import_node_fs6.promises.mkdtemp(import_node_path11.default.join(import_node_os3.default.tmpdir(), "pmate-screenshot-"));
-    const filePath = import_node_path11.default.join(dir, `screenshot-${index}.png`);
+    const dir = await import_node_fs7.promises.mkdtemp(import_node_path12.default.join(import_node_os4.default.tmpdir(), "pmate-screenshot-"));
+    const filePath = import_node_path12.default.join(dir, `screenshot-${index}.png`);
     try {
       const code = await this.run("screencapture", ["-i", "-x", filePath], true);
       if (code !== 0) {
         throw new Error("Screenshot capture canceled or failed.");
       }
-      const buffer = await import_node_fs6.promises.readFile(filePath);
+      const buffer = await import_node_fs7.promises.readFile(filePath);
       if (buffer.length === 0) {
         throw new Error("Screenshot capture produced an empty file.");
       }
@@ -13586,7 +13803,7 @@ var LinearCommandHandler = class {
       return { buffer, mime, filename: `screenshot-${index}.${extension}` };
     } finally {
       try {
-        await import_node_fs6.promises.rm(dir, { recursive: true, force: true });
+        await import_node_fs7.promises.rm(dir, { recursive: true, force: true });
       } catch {
       }
     }
@@ -13730,17 +13947,17 @@ var LinearCommandHandler = class {
     return compact.length > limit ? `${compact.slice(0, limit)}...` : compact;
   }
   async convertToPng(buffer, ext) {
-    const dir = await import_node_fs6.promises.mkdtemp(import_node_path11.default.join(import_node_os3.default.tmpdir(), "pmate-"));
-    const inputPath = import_node_path11.default.join(dir, `clipboard.${ext}`);
-    const outputPath = import_node_path11.default.join(dir, "clipboard.png");
+    const dir = await import_node_fs7.promises.mkdtemp(import_node_path12.default.join(import_node_os4.default.tmpdir(), "pmate-"));
+    const inputPath = import_node_path12.default.join(dir, `clipboard.${ext}`);
+    const outputPath = import_node_path12.default.join(dir, "clipboard.png");
     try {
-      await import_node_fs6.promises.writeFile(inputPath, buffer);
+      await import_node_fs7.promises.writeFile(inputPath, buffer);
       const stderr = await this.runCapture(
         "sips",
         ["-s", "format", "png", inputPath, "--out", outputPath],
         true
       );
-      const out = await import_node_fs6.promises.readFile(outputPath);
+      const out = await import_node_fs7.promises.readFile(outputPath);
       if (this.detectImageMime(out) !== "image/png") {
         throw new Error(
           stderr?.trim() ? `Failed to convert clipboard ${ext} to PNG: ${stderr.trim()}` : `Failed to convert clipboard ${ext} to PNG.`
@@ -13749,14 +13966,14 @@ var LinearCommandHandler = class {
       return out;
     } finally {
       try {
-        await import_node_fs6.promises.rm(dir, { recursive: true, force: true });
+        await import_node_fs7.promises.rm(dir, { recursive: true, force: true });
       } catch {
       }
     }
   }
   captureClipboard(preferred) {
     return new Promise((resolve, reject) => {
-      const child = (0, import_node_child_process7.spawn)("pbpaste", ["-Prefer", preferred], {
+      const child = (0, import_node_child_process8.spawn)("pbpaste", ["-Prefer", preferred], {
         stdio: ["ignore", "pipe", "pipe"]
       });
       const chunks = [];
@@ -13966,7 +14183,7 @@ var LinearCommandHandler = class {
   }
   run(command, args, quietError = false, env, cwd) {
     return new Promise((resolve, reject) => {
-      const child = (0, import_node_child_process7.spawn)(command, args, {
+      const child = (0, import_node_child_process8.spawn)(command, args, {
         stdio: quietError ? "ignore" : "inherit",
         env: env ?? process.env,
         cwd
@@ -13985,7 +14202,7 @@ var LinearCommandHandler = class {
   }
   runCapture(command, args, allowFailure = false, env, cwd) {
     return new Promise((resolve, reject) => {
-      const child = (0, import_node_child_process7.spawn)(command, args, {
+      const child = (0, import_node_child_process8.spawn)(command, args, {
         stdio: ["ignore", "pipe", "pipe"],
         env: env ?? process.env,
         cwd
@@ -14043,7 +14260,7 @@ var LinearCommandHandler = class {
     return this.runCapture("gh", args, allowFailure, await this.getGhEnv(cwd), cwd);
   }
   resolveCwd(value) {
-    return value ? import_node_path11.default.resolve(process.cwd(), value) : process.cwd();
+    return value ? import_node_path12.default.resolve(process.cwd(), value) : process.cwd();
   }
   createOpenAiClient() {
     const config = loadPmateConfig();
@@ -14095,8 +14312,8 @@ function sleep2(ms) {
 }
 
 // src/commands/NotionCommandHandler.ts
-var import_node_fs7 = require("fs");
-var import_node_path12 = __toESM(require("path"));
+var import_node_fs8 = require("fs");
+var import_node_path13 = __toESM(require("path"));
 
 // src/services/NotionService.ts
 var NotionService = class {
@@ -14335,9 +14552,9 @@ ${indent}\`\`\``;
   static richTextToPlain(richText) {
     return richText.map((item) => item.plain_text ?? item.text?.content ?? "").join("").trim();
   }
-  static async requestJson(path24, init) {
+  static async requestJson(path25, init) {
     const token = this.getToken();
-    const response = await fetch(`${this.baseUrl}${path24}`, {
+    const response = await fetch(`${this.baseUrl}${path25}`, {
       method: init.method,
       headers: {
         Authorization: `Bearer ${token}`,
@@ -14435,17 +14652,17 @@ var NotionCommandHandler = class {
     if (!args.filePath) {
       return "";
     }
-    const resolved = import_node_path12.default.resolve(process.cwd(), args.filePath);
-    return (0, import_node_fs7.readFileSync)(resolved, "utf8");
+    const resolved = import_node_path13.default.resolve(process.cwd(), args.filePath);
+    return (0, import_node_fs8.readFileSync)(resolved, "utf8");
   }
 };
 
 // src/commands/QrcodeCommandHandler.ts
-var import_node_child_process8 = require("child_process");
-var import_node_fs8 = require("fs");
-var import_node_os4 = __toESM(require("os"));
-var import_node_path13 = __toESM(require("path"));
-var import_promises3 = require("readline/promises");
+var import_node_child_process9 = require("child_process");
+var import_node_fs9 = require("fs");
+var import_node_os5 = __toESM(require("os"));
+var import_node_path14 = __toESM(require("path"));
+var import_promises4 = require("readline/promises");
 var import_jsqr = __toESM(require("jsqr"));
 var import_pngjs = require("pngjs");
 var QrcodeCommandHandler = class {
@@ -14470,14 +14687,14 @@ var QrcodeCommandHandler = class {
       ui.success("QR code value:", value);
     } finally {
       try {
-        await import_node_fs8.promises.rm(dir, { recursive: true, force: true });
+        await import_node_fs9.promises.rm(dir, { recursive: true, force: true });
       } catch {
       }
     }
   }
   async captureScreenshot() {
     ui.info("Capture a QR code screenshot now (macOS screencapture).");
-    const rl = (0, import_promises3.createInterface)({
+    const rl = (0, import_promises4.createInterface)({
       input: process.stdin,
       output: process.stdout
     });
@@ -14486,13 +14703,13 @@ var QrcodeCommandHandler = class {
     } finally {
       rl.close();
     }
-    const dir = await import_node_fs8.promises.mkdtemp(import_node_path13.default.join(import_node_os4.default.tmpdir(), "pmate-qrcode-"));
-    const filePath = import_node_path13.default.join(dir, "qrcode.png");
+    const dir = await import_node_fs9.promises.mkdtemp(import_node_path14.default.join(import_node_os5.default.tmpdir(), "pmate-qrcode-"));
+    const filePath = import_node_path14.default.join(dir, "qrcode.png");
     const code = await this.run("screencapture", ["-i", "-x", filePath], true);
     if (code !== 0) {
       throw new Error("Screenshot capture canceled or failed.");
     }
-    const buffer = await import_node_fs8.promises.readFile(filePath);
+    const buffer = await import_node_fs9.promises.readFile(filePath);
     if (buffer.length === 0) {
       throw new Error("Screenshot capture produced an empty file.");
     }
@@ -14508,7 +14725,7 @@ var QrcodeCommandHandler = class {
   async decodeQr(filePath) {
     let buffer;
     try {
-      buffer = await import_node_fs8.promises.readFile(filePath);
+      buffer = await import_node_fs9.promises.readFile(filePath);
     } catch {
       return null;
     }
@@ -14528,7 +14745,7 @@ var QrcodeCommandHandler = class {
     return value ? value : null;
   }
   async promptValue(detected) {
-    const rl = (0, import_promises3.createInterface)({
+    const rl = (0, import_promises4.createInterface)({
       input: process.stdin,
       output: process.stdout
     });
@@ -14549,7 +14766,7 @@ var QrcodeCommandHandler = class {
   }
   run(command, args, quietError = false, env, cwd) {
     return new Promise((resolve, reject) => {
-      const child = (0, import_node_child_process8.spawn)(command, args, {
+      const child = (0, import_node_child_process9.spawn)(command, args, {
         stdio: quietError ? "ignore" : "inherit",
         env: env ?? process.env,
         cwd
@@ -14766,8 +14983,8 @@ function clampNumber(value, min, max, fallback) {
 }
 
 // src/commands/QuizCommandHandler.ts
-var import_node_fs9 = require("fs");
-var import_node_path14 = __toESM(require("path"));
+var import_node_fs10 = require("fs");
+var import_node_path15 = __toESM(require("path"));
 init_sessionStore();
 
 // src/services/QuizService.ts
@@ -15243,8 +15460,8 @@ var QuizCommandHandler = class {
       return;
     }
     if (args.action === "update-meta") {
-      const resolvedFilePath = import_node_path14.default.resolve(process.cwd(), args.filePath);
-      const metadata = JSON.parse((0, import_node_fs9.readFileSync)(resolvedFilePath, "utf8"));
+      const resolvedFilePath = import_node_path15.default.resolve(process.cwd(), args.filePath);
+      const metadata = JSON.parse((0, import_node_fs10.readFileSync)(resolvedFilePath, "utf8"));
       const result = await updateQuizPaperMetadata({
         apiBaseUrl,
         linkBaseUrl,
@@ -15256,8 +15473,8 @@ var QuizCommandHandler = class {
       return;
     }
     if (args.action === "append-step") {
-      const resolvedFilePath = import_node_path14.default.resolve(process.cwd(), args.filePath);
-      const step = JSON.parse((0, import_node_fs9.readFileSync)(resolvedFilePath, "utf8"));
+      const resolvedFilePath = import_node_path15.default.resolve(process.cwd(), args.filePath);
+      const step = JSON.parse((0, import_node_fs10.readFileSync)(resolvedFilePath, "utf8"));
       const result = await appendQuizPaperStep({
         apiBaseUrl,
         linkBaseUrl,
@@ -15270,8 +15487,8 @@ var QuizCommandHandler = class {
       return;
     }
     if (args.action === "update-step") {
-      const resolvedFilePath = import_node_path14.default.resolve(process.cwd(), args.filePath);
-      const step = JSON.parse((0, import_node_fs9.readFileSync)(resolvedFilePath, "utf8"));
+      const resolvedFilePath = import_node_path15.default.resolve(process.cwd(), args.filePath);
+      const step = JSON.parse((0, import_node_fs10.readFileSync)(resolvedFilePath, "utf8"));
       step.stepId = args.stepId;
       const result = await updateQuizPaperStep({
         apiBaseUrl,
@@ -15322,8 +15539,8 @@ var QuizCommandHandler = class {
       if (targetIndex < 0) {
         throw new Error(`\u672A\u627E\u5230 stepId=${args.stepId}\uFF0C\u65E0\u6CD5\u66F4\u65B0\u8BE5\u9898\u76EE\u3002`);
       }
-      const resolvedFilePath = import_node_path14.default.resolve(process.cwd(), args.filePath);
-      const nextStep = JSON.parse((0, import_node_fs9.readFileSync)(resolvedFilePath, "utf8"));
+      const resolvedFilePath = import_node_path15.default.resolve(process.cwd(), args.filePath);
+      const nextStep = JSON.parse((0, import_node_fs10.readFileSync)(resolvedFilePath, "utf8"));
       nextStep.stepId = args.stepId;
       const nextSteps = [...basePaper.steps];
       nextSteps[targetIndex] = nextStep;
@@ -15375,19 +15592,19 @@ var QuizCommandHandler = class {
 // src/commands/CollectCommandHandler.ts
 var import_playwright = require("playwright");
 var import_node_crypto4 = require("crypto");
-var import_node_fs11 = require("fs");
-var import_node_os6 = __toESM(require("os"));
-var import_node_path16 = __toESM(require("path"));
+var import_node_fs12 = require("fs");
+var import_node_os7 = __toESM(require("os"));
+var import_node_path17 = __toESM(require("path"));
 
 // src/collectStore.ts
 var import_node_crypto3 = require("crypto");
-var import_node_fs10 = require("fs");
-var import_node_os5 = __toESM(require("os"));
-var import_node_path15 = __toESM(require("path"));
+var import_node_fs11 = require("fs");
+var import_node_os6 = __toESM(require("os"));
+var import_node_path16 = __toESM(require("path"));
 function resolveCollectTarget(input) {
   const endpoint = input.endpoint ?? (input.source === "cc" ? "http://localhost:9223" : "http://localhost:9222");
   const sourceKey = input.source ?? `endpoint-${(0, import_node_crypto3.createHash)("sha1").update(endpoint).digest("hex").slice(0, 8)}`;
-  const rootDir = import_node_path15.default.join(import_node_os5.default.homedir(), ".pmate", "collect", sourceKey);
+  const rootDir = import_node_path16.default.join(import_node_os6.default.homedir(), ".pmate", "collect", sourceKey);
   return { sourceKey, endpoint, rootDir };
 }
 function toThreadKey(name) {
@@ -15399,7 +15616,7 @@ function toThreadKey(name) {
 async function readStoredThread(rootDir, threadKey) {
   const filePath = getThreadFilePath(rootDir, threadKey);
   try {
-    const raw = await import_node_fs10.promises.readFile(filePath, "utf8");
+    const raw = await import_node_fs11.promises.readFile(filePath, "utf8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -15407,13 +15624,13 @@ async function readStoredThread(rootDir, threadKey) {
 }
 async function writeStoredThread(rootDir, thread) {
   const filePath = getThreadFilePath(rootDir, thread.threadKey);
-  await import_node_fs10.promises.mkdir(import_node_path15.default.dirname(filePath), { recursive: true });
-  await import_node_fs10.promises.writeFile(filePath, JSON.stringify(thread, null, 2) + "\n", "utf8");
+  await import_node_fs11.promises.mkdir(import_node_path16.default.dirname(filePath), { recursive: true });
+  await import_node_fs11.promises.writeFile(filePath, JSON.stringify(thread, null, 2) + "\n", "utf8");
 }
 async function writeStoredIndex(rootDir, index) {
-  await import_node_fs10.promises.mkdir(rootDir, { recursive: true });
-  const filePath = import_node_path15.default.join(rootDir, "index.json");
-  await import_node_fs10.promises.writeFile(filePath, JSON.stringify(index, null, 2) + "\n", "utf8");
+  await import_node_fs11.promises.mkdir(rootDir, { recursive: true });
+  const filePath = import_node_path16.default.join(rootDir, "index.json");
+  await import_node_fs11.promises.writeFile(filePath, JSON.stringify(index, null, 2) + "\n", "utf8");
 }
 function mergeMessages(existing, incoming) {
   const seen = new Set(existing.map((message) => message.hash));
@@ -15430,7 +15647,7 @@ function mergeMessages(existing, incoming) {
   return { messages: merged, added };
 }
 function getThreadFilePath(rootDir, threadKey) {
-  return import_node_path15.default.join(rootDir, "threads", `${threadKey}.json`);
+  return import_node_path16.default.join(rootDir, "threads", `${threadKey}.json`);
 }
 
 // src/commands/CollectCommandHandler.ts
@@ -15842,19 +16059,19 @@ function parseMessageText(rawText) {
   };
 }
 async function toDisplayableImagePath(src) {
-  if (!import_node_path16.default.isAbsolute(src)) {
+  if (!import_node_path17.default.isAbsolute(src)) {
     return src;
   }
-  const ext = import_node_path16.default.extname(src);
+  const ext = import_node_path17.default.extname(src);
   if (ext) {
     return src;
   }
   try {
-    const stat = await import_node_fs11.promises.stat(src);
+    const stat = await import_node_fs12.promises.stat(src);
     if (!stat.isFile()) {
       return src;
     }
-    const fh = await import_node_fs11.promises.open(src, "r");
+    const fh = await import_node_fs12.promises.open(src, "r");
     try {
       const buf = Buffer.alloc(32);
       const { bytesRead } = await fh.read(buf, 0, 32, 0);
@@ -15863,17 +16080,17 @@ async function toDisplayableImagePath(src) {
       if (!guessedExt) {
         return src;
       }
-      const cacheDir = import_node_path16.default.join(
-        import_node_os6.default.homedir(),
+      const cacheDir = import_node_path17.default.join(
+        import_node_os7.default.homedir(),
         ".pmate",
         "messages",
         "images"
       );
-      await import_node_fs11.promises.mkdir(cacheDir, { recursive: true });
+      await import_node_fs12.promises.mkdir(cacheDir, { recursive: true });
       const base = (0, import_node_crypto4.createHash)("sha1").update(src).digest("hex");
-      const displayPath = import_node_path16.default.join(cacheDir, `${base}.${guessedExt}`);
-      await import_node_fs11.promises.rm(displayPath, { force: true }).catch(() => void 0);
-      await import_node_fs11.promises.copyFile(src, displayPath);
+      const displayPath = import_node_path17.default.join(cacheDir, `${base}.${guessedExt}`);
+      await import_node_fs12.promises.rm(displayPath, { force: true }).catch(() => void 0);
+      await import_node_fs12.promises.copyFile(src, displayPath);
       return displayPath;
     } finally {
       await fh.close();
@@ -15899,8 +16116,8 @@ function guessImageExtension(header) {
 }
 
 // src/commands/AgentCommandHandler.ts
-var import_node_fs12 = require("fs");
-var import_node_path17 = __toESM(require("path"));
+var import_node_fs13 = require("fs");
+var import_node_path18 = __toESM(require("path"));
 init_AgentLlmClient();
 init_sessionStore();
 
@@ -15933,8 +16150,8 @@ function descriptorPathSegments(descriptor) {
   return ["chains", normalized.chain, "namespaces", normalized.ns, normalized.kind, normalized.name];
 }
 function buildPathUrl(baseUrl, pathSegments, query) {
-  const path24 = `/${pathSegments.map((segment) => encodeURIComponent(segment)).join("/")}`;
-  const url = new URL(path24, baseUrl);
+  const path25 = `/${pathSegments.map((segment) => encodeURIComponent(segment)).join("/")}`;
+  const url = new URL(path25, baseUrl);
   if (query) {
     for (const [key, value] of Object.entries(query)) {
       url.searchParams.set(key, String(value));
@@ -16366,11 +16583,11 @@ var AgentCommandHandler = class {
     }).token;
   }
   readJsonFile(filePath) {
-    const absolutePath = import_node_path17.default.resolve(process.cwd(), filePath);
-    if (!(0, import_node_fs12.existsSync)(absolutePath)) {
+    const absolutePath = import_node_path18.default.resolve(process.cwd(), filePath);
+    if (!(0, import_node_fs13.existsSync)(absolutePath)) {
       throw new Error(`JSON file not found: ${absolutePath}`);
     }
-    const raw = (0, import_node_fs12.readFileSync)(absolutePath, "utf8");
+    const raw = (0, import_node_fs13.readFileSync)(absolutePath, "utf8");
     try {
       return JSON.parse(raw);
     } catch (error) {
@@ -16381,7 +16598,7 @@ var AgentCommandHandler = class {
   readJsonObjectFile(filePath) {
     const parsed = this.readJsonFile(filePath);
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-      const absolutePath = import_node_path17.default.resolve(process.cwd(), filePath);
+      const absolutePath = import_node_path18.default.resolve(process.cwd(), filePath);
       throw new Error(`Invalid JSON in ${absolutePath}: expected an object`);
     }
     return parsed;
@@ -16465,8 +16682,8 @@ var AgentCommandHandler = class {
 };
 
 // src/commands/RunnerCommandHandler.ts
-var import_node_fs13 = require("fs");
-var import_node_path18 = __toESM(require("path"));
+var import_node_fs14 = require("fs");
+var import_node_path19 = __toESM(require("path"));
 init_sessionStore();
 init_namespacedRef();
 var RunnerCommandHandler = class {
@@ -16561,11 +16778,11 @@ var RunnerCommandHandler = class {
     }).token;
   }
   readJsonFile(filePath) {
-    const absolutePath = import_node_path18.default.resolve(process.cwd(), filePath);
-    if (!(0, import_node_fs13.existsSync)(absolutePath)) {
+    const absolutePath = import_node_path19.default.resolve(process.cwd(), filePath);
+    if (!(0, import_node_fs14.existsSync)(absolutePath)) {
       throw new Error(`JSON file not found: ${absolutePath}`);
     }
-    const raw = (0, import_node_fs13.readFileSync)(absolutePath, "utf8");
+    const raw = (0, import_node_fs14.readFileSync)(absolutePath, "utf8");
     try {
       return JSON.parse(raw);
     } catch (error) {
@@ -16684,8 +16901,8 @@ var NsCommandHandler = class {
 };
 
 // src/commands/StoreCommandHandler.ts
-var import_node_fs14 = require("fs");
-var import_node_path19 = __toESM(require("path"));
+var import_node_fs15 = require("fs");
+var import_node_path20 = __toESM(require("path"));
 var StoreCommandHandler = class {
   async handle(args) {
     if (args.scope === "namespace") {
@@ -16827,11 +17044,11 @@ var StoreCommandHandler = class {
     return payload.data ?? [];
   }
   readJsonFile(filePath) {
-    const absolutePath = import_node_path19.default.resolve(process.cwd(), filePath);
-    if (!(0, import_node_fs14.existsSync)(absolutePath)) {
+    const absolutePath = import_node_path20.default.resolve(process.cwd(), filePath);
+    if (!(0, import_node_fs15.existsSync)(absolutePath)) {
       throw new Error(`JSON file not found: ${absolutePath}`);
     }
-    const raw = (0, import_node_fs14.readFileSync)(absolutePath, "utf8");
+    const raw = (0, import_node_fs15.readFileSync)(absolutePath, "utf8");
     try {
       return JSON.parse(raw);
     } catch (error) {
@@ -16883,8 +17100,8 @@ var StoreCommandHandler = class {
 };
 
 // src/commands/AppCommandHandler.ts
-var import_node_fs15 = require("fs");
-var import_node_path20 = __toESM(require("path"));
+var import_node_fs16 = require("fs");
+var import_node_path21 = __toESM(require("path"));
 init_sessionStore();
 init_namespacedRef();
 var AppCommandHandler = class {
@@ -17001,11 +17218,11 @@ var AppCommandHandler = class {
     }).token;
   }
   readJsonFile(filePath) {
-    const absolutePath = import_node_path20.default.resolve(process.cwd(), filePath);
-    if (!(0, import_node_fs15.existsSync)(absolutePath)) {
+    const absolutePath = import_node_path21.default.resolve(process.cwd(), filePath);
+    if (!(0, import_node_fs16.existsSync)(absolutePath)) {
       throw new Error(`JSON file not found: ${absolutePath}`);
     }
-    const raw = (0, import_node_fs15.readFileSync)(absolutePath, "utf8");
+    const raw = (0, import_node_fs16.readFileSync)(absolutePath, "utf8");
     try {
       return JSON.parse(raw);
     } catch (error) {
@@ -17085,14 +17302,14 @@ function readNamespaceFromPayload(payload) {
 }
 
 // src/commands/ServiceCommandHandler.ts
-var import_node_fs17 = require("fs");
-var import_node_path22 = __toESM(require("path"));
+var import_node_fs18 = require("fs");
+var import_node_path23 = __toESM(require("path"));
 
 // src/services/ServiceRuntimeRunner.ts
-var import_node_fs16 = require("fs");
-var import_node_os7 = __toESM(require("os"));
-var import_node_path21 = __toESM(require("path"));
-var import_node_child_process9 = require("child_process");
+var import_node_fs17 = require("fs");
+var import_node_os8 = __toESM(require("os"));
+var import_node_path22 = __toESM(require("path"));
+var import_node_child_process10 = require("child_process");
 var import_node_readline = require("readline");
 var import_chalk3 = __toESM(require("chalk"));
 var ServiceRuntimeRunner = class {
@@ -17204,14 +17421,14 @@ var ServiceRuntimeRunner = class {
   }
   resolveRepoRoot(service, cwd) {
     if (cwd) {
-      return import_node_path21.default.resolve(process.cwd(), cwd);
+      return import_node_path22.default.resolve(process.cwd(), cwd);
     }
     const repository = this.getDeploy(service).repository?.trim();
     if (repository) {
       const repoName = repository.replace(/\/+$/, "").split("/").pop()?.replace(/\.git$/i, "");
       if (repoName) {
-        const candidate = import_node_path21.default.join(import_node_os7.default.homedir(), "dev", "pmate", repoName);
-        if ((0, import_node_fs16.existsSync)(candidate)) {
+        const candidate = import_node_path22.default.join(import_node_os8.default.homedir(), "dev", "pmate", repoName);
+        if ((0, import_node_fs17.existsSync)(candidate)) {
           return candidate;
         }
       }
@@ -17224,12 +17441,12 @@ var ServiceRuntimeRunner = class {
     if (!dir) {
       throw new Error(`Missing deploy.dir for ${service.id}`);
     }
-    return import_node_path21.default.resolve(repoRoot, dir);
+    return import_node_path22.default.resolve(repoRoot, dir);
   }
   async deployVite(service, options) {
     const appDir = this.resolveLocalDir(service, options.cwd);
-    const packageJsonPath = import_node_path21.default.join(appDir, "package.json");
-    if (!(0, import_node_fs16.existsSync)(packageJsonPath)) {
+    const packageJsonPath = import_node_path22.default.join(appDir, "package.json");
+    if (!(0, import_node_fs17.existsSync)(packageJsonPath)) {
       throw new Error(`No package.json found at ${packageJsonPath}`);
     }
     const pkg2 = this.loadPackageJson(packageJsonPath);
@@ -17238,8 +17455,8 @@ var ServiceRuntimeRunner = class {
       throw new Error(`Missing package name in ${packageJsonPath}`);
     }
     await this.runCommand("pnpm", ["--filter", pkgName, "build"], this.resolveRepoRoot(service, options.cwd));
-    const distDir = import_node_path21.default.join(appDir, "dist");
-    if (!(0, import_node_fs16.existsSync)(distDir)) {
+    const distDir = import_node_path22.default.join(appDir, "dist");
+    if (!(0, import_node_fs17.existsSync)(distDir)) {
       throw new Error(`No dist directory found at ${distDir}`);
     }
     const bucketName = this.getDeploy(service).bucket?.trim();
@@ -17250,8 +17467,8 @@ var ServiceRuntimeRunner = class {
   }
   async deployStatic(service, options) {
     const appDir = this.resolveLocalDir(service, options.cwd);
-    const srcDir = import_node_path21.default.join(appDir, "src");
-    if (!(0, import_node_fs16.existsSync)(srcDir)) {
+    const srcDir = import_node_path22.default.join(appDir, "src");
+    if (!(0, import_node_fs17.existsSync)(srcDir)) {
       throw new Error(`No src directory found at ${srcDir}`);
     }
     const bucketName = this.getDeploy(service).bucket?.trim();
@@ -17369,7 +17586,7 @@ var ServiceRuntimeRunner = class {
       const serverAddress = await resolveServerAddress(server);
       const templateName = serviceType === "ws" ? "nginx.ws.template" : "nginx.rest.template";
       const templatePath = this.resolveTemplatePath(templateName);
-      const template = (0, import_node_fs16.readFileSync)(templatePath, "utf8");
+      const template = (0, import_node_fs17.readFileSync)(templatePath, "utf8");
       const host = `${subdomain}.${deploy.domain?.trim() || "pmate.chat"}`;
       const rendered = template.replace(/\$\{\{PORT\}\}/g, String(port)).replace(/\$\{\{HOSTS\}\}/g, host).replace(/\$\{\{HOST\}\}/g, host);
       const remotePath = `/etc/nginx/sites-enabled/${subdomain}.conf`;
@@ -17401,11 +17618,11 @@ var ServiceRuntimeRunner = class {
     }
     if (config.ensurePackageJson) {
       const appDir = this.resolveLocalDir(service, options.cwd);
-      const packageJsonPath = import_node_path21.default.join(appDir, "package.json");
-      if (!(0, import_node_fs16.existsSync)(packageJsonPath)) {
+      const packageJsonPath = import_node_path22.default.join(appDir, "package.json");
+      if (!(0, import_node_fs17.existsSync)(packageJsonPath)) {
         throw new Error(`Missing package.json at ${packageJsonPath}`);
       }
-      const pkgStat = (0, import_node_fs16.statSync)(packageJsonPath);
+      const pkgStat = (0, import_node_fs17.statSync)(packageJsonPath);
       if (!pkgStat.isFile()) {
         throw new Error(`package.json is not a file at ${packageJsonPath}`);
       }
@@ -17828,9 +18045,9 @@ var ServiceRuntimeRunner = class {
     return tokens;
   }
   readPathValue(source, pathExpr) {
-    const path24 = pathExpr.split(".").map((segment) => segment.trim()).filter(Boolean);
+    const path25 = pathExpr.split(".").map((segment) => segment.trim()).filter(Boolean);
     let cursor = source;
-    for (const segment of path24) {
+    for (const segment of path25) {
       if (!cursor || typeof cursor !== "object" || Array.isArray(cursor)) {
         return void 0;
       }
@@ -17873,12 +18090,12 @@ var ServiceRuntimeRunner = class {
   }
   resolveTemplatePath(templateName) {
     const candidates = [
-      import_node_path21.default.join(__dirname, "..", "templates", templateName),
-      import_node_path21.default.join(__dirname, "..", "src", "templates", templateName),
-      import_node_path21.default.join(__dirname, "templates", templateName)
+      import_node_path22.default.join(__dirname, "..", "templates", templateName),
+      import_node_path22.default.join(__dirname, "..", "src", "templates", templateName),
+      import_node_path22.default.join(__dirname, "templates", templateName)
     ];
     for (const candidate of candidates) {
-      if ((0, import_node_fs16.existsSync)(candidate)) {
+      if ((0, import_node_fs17.existsSync)(candidate)) {
         return candidate;
       }
     }
@@ -17887,7 +18104,7 @@ var ServiceRuntimeRunner = class {
   writeRemoteConfig(server, content, remotePath) {
     return new Promise((resolve, reject) => {
       const target = `pmate@${server}`;
-      const child = (0, import_node_child_process9.spawn)("ssh", [target, "sudo", "tee", remotePath], {
+      const child = (0, import_node_child_process10.spawn)("ssh", [target, "sudo", "tee", remotePath], {
         stdio: ["pipe", "inherit", "inherit"]
       });
       child.on("error", reject);
@@ -17902,7 +18119,7 @@ var ServiceRuntimeRunner = class {
   reloadNginx(server) {
     return new Promise((resolve, reject) => {
       const target = `pmate@${server}`;
-      const child = (0, import_node_child_process9.spawn)("ssh", [target, "sudo", "nginx", "-s", "reload"], {
+      const child = (0, import_node_child_process10.spawn)("ssh", [target, "sudo", "nginx", "-s", "reload"], {
         stdio: ["ignore", "inherit", "inherit"]
       });
       child.on("error", reject);
@@ -17910,7 +18127,7 @@ var ServiceRuntimeRunner = class {
     });
   }
   loadPackageJson(packageJsonPath) {
-    const raw = (0, import_node_fs16.readFileSync)(packageJsonPath, "utf8");
+    const raw = (0, import_node_fs17.readFileSync)(packageJsonPath, "utf8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object") {
       throw new Error(`Invalid package.json at ${packageJsonPath}`);
@@ -17919,12 +18136,12 @@ var ServiceRuntimeRunner = class {
   }
   writePackageJson(packageJsonPath, data) {
     const serialized = JSON.stringify(data, null, 2);
-    (0, import_node_fs16.writeFileSync)(packageJsonPath, `${serialized}
+    (0, import_node_fs17.writeFileSync)(packageJsonPath, `${serialized}
 `, "utf8");
   }
   runCommand(command, args, cwd) {
     return new Promise((resolve, reject) => {
-      const child = (0, import_node_child_process9.spawn)(command, args, { cwd, stdio: "inherit" });
+      const child = (0, import_node_child_process10.spawn)(command, args, { cwd, stdio: "inherit" });
       child.on("error", reject);
       child.on("close", (code) => code === 0 ? resolve() : reject(new Error(`${command} exited with code ${code}`)));
     });
@@ -17932,7 +18149,7 @@ var ServiceRuntimeRunner = class {
   runRemoteCommand(server, command) {
     return new Promise((resolve, reject) => {
       const target = `pmate@${server}`;
-      const child = (0, import_node_child_process9.spawn)("ssh", buildSshBashArgs(target, command), { stdio: "inherit" });
+      const child = (0, import_node_child_process10.spawn)("ssh", buildSshBashArgs(target, command), { stdio: "inherit" });
       child.on("error", reject);
       child.on("close", (code) => code === 0 ? resolve() : reject(new Error(`ssh to ${server} exited with code ${code}`)));
     });
@@ -18187,11 +18404,11 @@ var ServiceCommandHandler = class {
     return (baseUrl || process.env.PMATE_APPS_API_BASE_URL || "https://apps-api.pmate.chat").replace(/\/+$/, "");
   }
   readJsonFile(filePath) {
-    const absolutePath = import_node_path22.default.resolve(process.cwd(), filePath);
-    if (!(0, import_node_fs17.existsSync)(absolutePath)) {
+    const absolutePath = import_node_path23.default.resolve(process.cwd(), filePath);
+    if (!(0, import_node_fs18.existsSync)(absolutePath)) {
       throw new Error(`JSON file not found: ${absolutePath}`);
     }
-    const raw = (0, import_node_fs17.readFileSync)(absolutePath, "utf8");
+    const raw = (0, import_node_fs18.readFileSync)(absolutePath, "utf8");
     try {
       return JSON.parse(raw);
     } catch (error) {
@@ -18290,9 +18507,9 @@ var ServiceCommandHandler = class {
 };
 
 // src/commands/VercelCommandHandler.ts
-var import_node_child_process10 = require("child_process");
-var import_node_util = require("util");
-var execFileAsync = (0, import_node_util.promisify)(import_node_child_process10.execFile);
+var import_node_child_process11 = require("child_process");
+var import_node_util2 = require("util");
+var execFileAsync2 = (0, import_node_util2.promisify)(import_node_child_process11.execFile);
 function parseDeploymentTimestamp(deployment) {
   const candidates = [deployment.createdAt, deployment.readyAt, deployment.ready];
   for (const value of candidates) {
@@ -18320,7 +18537,7 @@ function filterDeploymentsFromLastWeek(deployments, now = Date.now()) {
   });
 }
 var VercelCommandHandler = class {
-  constructor(runCommand = async (command, args) => execFileAsync(command, args, { maxBuffer: 1024 * 1024 * 20 }), getConfig = loadPmateConfig) {
+  constructor(runCommand = async (command, args) => execFileAsync2(command, args, { maxBuffer: 1024 * 1024 * 20 }), getConfig = loadPmateConfig) {
     this.runCommand = runCommand;
     this.getConfig = getConfig;
   }
@@ -20220,9 +20437,95 @@ function requireValue9(tokens, optionName) {
   return value;
 }
 
+// src/prepareDevCommandParser.ts
+function parsePrepareDevArgs(tokens) {
+  const rest = [...tokens];
+  const repo = rest.shift();
+  if (!repo || repo.startsWith("-")) {
+    throw new Error("Missing repo name. Usage: prepare-dev <repo> --open|--close [options]");
+  }
+  if (repo.includes("/") || repo.includes("\\")) {
+    throw new Error(`Invalid repo name: ${repo}`);
+  }
+  let open = false;
+  let close = false;
+  let envIndex;
+  let note;
+  let envRoot;
+  let baseRoot;
+  let json = false;
+  while (rest.length > 0) {
+    const token = rest.shift();
+    switch (token) {
+      case "--open":
+        open = true;
+        break;
+      case "--close":
+        close = true;
+        break;
+      case "--env": {
+        const rawValue = requireValue10(rest, token);
+        const parsed = Number.parseInt(rawValue, 10);
+        if (!Number.isInteger(parsed) || parsed < 0) {
+          throw new Error(`Invalid --env value: ${rawValue}`);
+        }
+        envIndex = parsed;
+        break;
+      }
+      case "--env-root":
+        envRoot = requireValue10(rest, token);
+        break;
+      case "--base-root":
+        baseRoot = requireValue10(rest, token);
+        break;
+      case "--note":
+        note = requireValue10(rest, token);
+        break;
+      case "--json":
+        json = true;
+        break;
+      default:
+        throw new Error(`Unknown prepare-dev option: ${token}`);
+    }
+  }
+  if (open === close) {
+    throw new Error("Use exactly one of --open or --close.");
+  }
+  if (open) {
+    return {
+      type: "prepare-dev" /* PrepareDev */,
+      action: "open",
+      repo,
+      note,
+      envRoot,
+      baseRoot,
+      json
+    };
+  }
+  if (envIndex === void 0) {
+    throw new Error("Missing required option --env for prepare-dev --close.");
+  }
+  return {
+    type: "prepare-dev" /* PrepareDev */,
+    action: "close",
+    repo,
+    envIndex,
+    envRoot,
+    baseRoot,
+    json
+  };
+}
+function requireValue10(tokens, option) {
+  const value = tokens.shift();
+  if (!value || value.startsWith("-")) {
+    throw new Error(`Missing value for ${option}`);
+  }
+  return value;
+}
+
 // src/index.ts
 var pkg = JSON.parse(
-  (0, import_node_fs18.readFileSync)(import_node_path23.default.resolve(__dirname, "..", "package.json"), "utf8")
+  (0, import_node_fs19.readFileSync)(import_node_path24.default.resolve(__dirname, "..", "package.json"), "utf8")
 );
 var HELP_TEXT = [
   import_chalk4.default.bold(`pmate v${pkg.version}`),
@@ -20248,6 +20551,9 @@ var HELP_TEXT = [
   `  ${import_chalk4.default.gray("                  [app] <app-name> [--cwd <dir>]")}`,
   `  ${import_chalk4.default.cyan("dev")}              Run the dev script for app dir from .pmate.yaml`,
   `  ${import_chalk4.default.gray("                  <app-name> [--cwd <dir>]")}`,
+  `  ${import_chalk4.default.cyan("prepare-dev")}      Open or close a local dev environment under ~/dev/pmate-envs`,
+  `  ${import_chalk4.default.gray("                  <repo> --open [--note <text>] [--env-root <dir>] [--base-root <dir>] [--json]")}`,
+  `  ${import_chalk4.default.gray("                  <repo> --close --env <n> [--env-root <dir>] [--base-root <dir>] [--json]")}`,
   `  ${import_chalk4.default.cyan("env")}              Manage app env vars on the server`,
   `  ${import_chalk4.default.gray("                  <app-name> --list|--set <key> --value <value> [--delete <key>] [--cwd <dir>] [--verbose|-v]")}`,
   `  ${import_chalk4.default.cyan("pr")}               Create or update GitHub PRs with AI assistance`,
@@ -20424,7 +20730,7 @@ function parseCommandArgs(args) {
       const token = rest.shift();
       switch (token) {
         case "--app":
-          app = requireValue10(rest, token);
+          app = requireValue11(rest, token);
           break;
         default:
           throw new Error(`Unknown login option: ${token}`);
@@ -20450,6 +20756,9 @@ function parseCommandArgs(args) {
   if (args.rest[0] === "dev") {
     return parseDevArgs(args.rest.slice(1));
   }
+  if (args.rest[0] === "prepare-dev") {
+    return parsePrepareDevArgs(args.rest.slice(1));
+  }
   if (args.rest[0] === "oss") {
     return parseOssArgs(args.rest.slice(1));
   }
@@ -20524,7 +20833,7 @@ function parseVercelArgs(tokens) {
       const token = rest.shift();
       switch (token) {
         case "--scope":
-          scope = requireValue10(rest, token);
+          scope = requireValue11(rest, token);
           break;
         default:
           throw new Error(`Unknown vercel option: ${token}`);
@@ -20544,10 +20853,10 @@ function parseVercelArgs(tokens) {
       const token = rest.shift();
       switch (token) {
         case "--scope":
-          scope = requireValue10(rest, token);
+          scope = requireValue11(rest, token);
           break;
         case "--project":
-          project = requireValue10(rest, token);
+          project = requireValue11(rest, token);
           break;
         case "--last-week":
           lastWeek = true;
@@ -20578,16 +20887,16 @@ function parseAddDnsArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--type":
-        options.dnsType = requireValue10(rest, token);
+        options.dnsType = requireValue11(rest, token);
         break;
       case "--value":
-        options.dnsValue = requireValue10(rest, token);
+        options.dnsValue = requireValue11(rest, token);
         break;
       case "--rr":
-        options.dnsRr = requireValue10(rest, token);
+        options.dnsRr = requireValue11(rest, token);
         break;
       case "--ttl": {
-        const ttlValue = requireValue10(rest, token);
+        const ttlValue = requireValue11(rest, token);
         const ttl = Number.parseInt(ttlValue, 10);
         if (!Number.isFinite(ttl) || ttl <= 0) {
           throw new Error(`Invalid --ttl value: ${ttlValue}`);
@@ -20596,7 +20905,7 @@ function parseAddDnsArgs(tokens) {
         break;
       }
       case "--domain":
-        options.dnsDomain = requireValue10(rest, token);
+        options.dnsDomain = requireValue11(rest, token);
         break;
       default:
         throw new Error(`Unknown add-dns option: ${token}`);
@@ -20629,13 +20938,13 @@ function parseBucketArgs(tokens) {
         options.bucketCreate = true;
         break;
       case "--name":
-        options.bucketName = requireValue10(rest, token);
+        options.bucketName = requireValue11(rest, token);
         break;
       case "--subdomain":
-        options.bucketSubdomain = requireValue10(rest, token);
+        options.bucketSubdomain = requireValue11(rest, token);
         break;
       case "--domain":
-        options.bucketDomain = requireValue10(rest, token);
+        options.bucketDomain = requireValue11(rest, token);
         break;
       default:
         throw new Error(`Unknown bucket option: ${token}`);
@@ -20667,7 +20976,7 @@ function parseDevArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--cwd":
-        options.devCwd = requireValue10(rest, token);
+        options.devCwd = requireValue11(rest, token);
         break;
       default:
         throw new Error(`Unknown dev option: ${token}`);
@@ -20687,7 +20996,7 @@ function parseDeleteArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--cwd":
-        deleteCwd = requireValue10(rest, token);
+        deleteCwd = requireValue11(rest, token);
         break;
       default:
         throw new Error(`Unknown delete option: ${token}`);
@@ -20721,13 +21030,13 @@ function parseOssArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--bucket":
-        bucket = requireValue10(rest, token);
+        bucket = requireValue11(rest, token);
         break;
       case "--file":
-        filePath = requireValue10(rest, token);
+        filePath = requireValue11(rest, token);
         break;
       case "--key":
-        objectKey = requireValue10(rest, token);
+        objectKey = requireValue11(rest, token);
         break;
       default:
         throw new Error(`Unknown oss option: ${token}`);
@@ -20760,7 +21069,7 @@ function parseEnvArgs(tokens) {
           throw new Error("Only one env action is allowed.");
         }
         action = "set";
-        key = requireValue10(rest, token);
+        key = requireValue11(rest, token);
         break;
       case "--list":
         if (action) {
@@ -20773,17 +21082,17 @@ function parseEnvArgs(tokens) {
           throw new Error("Only one env action is allowed.");
         }
         action = "delete";
-        key = requireValue10(rest, token);
+        key = requireValue11(rest, token);
         break;
       case "--value":
-        value = requireValue10(rest, token);
+        value = requireValue11(rest, token);
         break;
       case "--verbose":
       case "-v":
         verbose = true;
         break;
       case "--cwd":
-        cwd = requireValue10(rest, token);
+        cwd = requireValue11(rest, token);
         break;
       default:
         throw new Error(`Unknown env option: ${token}`);
@@ -20841,7 +21150,7 @@ function parseCommitArgs(tokens) {
         push = true;
         break;
       case "--cwd":
-        cwd = requireValue10(rest, token);
+        cwd = requireValue11(rest, token);
         break;
       default:
         throw new Error(`Unknown commit option: ${token}`);
@@ -20857,10 +21166,10 @@ function parseSummaryArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--pr":
-        prRef = requireValue10(rest, token);
+        prRef = requireValue11(rest, token);
         break;
       case "--cwd":
-        cwd = requireValue10(rest, token);
+        cwd = requireValue11(rest, token);
         break;
       default:
         throw new Error(`Unknown summary option: ${token}`);
@@ -20885,13 +21194,13 @@ function parseQuizArgs(tokens) {
       const token = rest.shift();
       switch (token) {
         case "--paper-id":
-          paperId = requireValue10(rest, token);
+          paperId = requireValue11(rest, token);
           break;
         case "--base-url":
-          apiBaseUrl = requireValue10(rest, token);
+          apiBaseUrl = requireValue11(rest, token);
           break;
         case "--link-base":
-          linkBaseUrl = requireValue10(rest, token);
+          linkBaseUrl = requireValue11(rest, token);
           break;
         default:
           throw new Error(`Unknown quiz create-draft option: ${token}`);
@@ -20917,16 +21226,16 @@ function parseQuizArgs(tokens) {
       const token = rest.shift();
       switch (token) {
         case "--paper-id":
-          paperId = requireValue10(rest, token);
+          paperId = requireValue11(rest, token);
           break;
         case "--file":
-          filePath = requireValue10(rest, token);
+          filePath = requireValue11(rest, token);
           break;
         case "--base-url":
-          apiBaseUrl = requireValue10(rest, token);
+          apiBaseUrl = requireValue11(rest, token);
           break;
         case "--link-base":
-          linkBaseUrl = requireValue10(rest, token);
+          linkBaseUrl = requireValue11(rest, token);
           break;
         default:
           throw new Error(`Unknown quiz update-meta option: ${token}`);
@@ -20956,16 +21265,16 @@ function parseQuizArgs(tokens) {
       const token = rest.shift();
       switch (token) {
         case "--paper-id":
-          paperId = requireValue10(rest, token);
+          paperId = requireValue11(rest, token);
           break;
         case "--file":
-          filePath = requireValue10(rest, token);
+          filePath = requireValue11(rest, token);
           break;
         case "--base-url":
-          apiBaseUrl = requireValue10(rest, token);
+          apiBaseUrl = requireValue11(rest, token);
           break;
         case "--link-base":
-          linkBaseUrl = requireValue10(rest, token);
+          linkBaseUrl = requireValue11(rest, token);
           break;
         default:
           throw new Error(`Unknown quiz append-step option: ${token}`);
@@ -20996,19 +21305,19 @@ function parseQuizArgs(tokens) {
       const token = rest.shift();
       switch (token) {
         case "--paper-id":
-          paperId = requireValue10(rest, token);
+          paperId = requireValue11(rest, token);
           break;
         case "--step-id":
-          stepId = requireValue10(rest, token);
+          stepId = requireValue11(rest, token);
           break;
         case "--file":
-          filePath = requireValue10(rest, token);
+          filePath = requireValue11(rest, token);
           break;
         case "--base-url":
-          apiBaseUrl = requireValue10(rest, token);
+          apiBaseUrl = requireValue11(rest, token);
           break;
         case "--link-base":
-          linkBaseUrl = requireValue10(rest, token);
+          linkBaseUrl = requireValue11(rest, token);
           break;
         default:
           throw new Error(`Unknown quiz update-step option: ${token}`);
@@ -21042,16 +21351,16 @@ function parseQuizArgs(tokens) {
       const token = rest.shift();
       switch (token) {
         case "--paper-id":
-          paperId = requireValue10(rest, token);
+          paperId = requireValue11(rest, token);
           break;
         case "--step-ids":
-          stepIdsRaw = requireValue10(rest, token);
+          stepIdsRaw = requireValue11(rest, token);
           break;
         case "--base-url":
-          apiBaseUrl = requireValue10(rest, token);
+          apiBaseUrl = requireValue11(rest, token);
           break;
         case "--link-base":
-          linkBaseUrl = requireValue10(rest, token);
+          linkBaseUrl = requireValue11(rest, token);
           break;
         default:
           throw new Error(`Unknown quiz reorder option: ${token}`);
@@ -21084,13 +21393,13 @@ function parseQuizArgs(tokens) {
       const token = rest.shift();
       switch (token) {
         case "--paper-id":
-          paperId = requireValue10(rest, token);
+          paperId = requireValue11(rest, token);
           break;
         case "--base-url":
-          apiBaseUrl = requireValue10(rest, token);
+          apiBaseUrl = requireValue11(rest, token);
           break;
         case "--link-base":
-          linkBaseUrl = requireValue10(rest, token);
+          linkBaseUrl = requireValue11(rest, token);
           break;
         default:
           throw new Error(`Unknown quiz activate option: ${token}`);
@@ -21115,13 +21424,13 @@ function parseQuizArgs(tokens) {
       const token = rest.shift();
       switch (token) {
         case "--paper-id":
-          paperId = requireValue10(rest, token);
+          paperId = requireValue11(rest, token);
           break;
         case "--base-url":
-          apiBaseUrl = requireValue10(rest, token);
+          apiBaseUrl = requireValue11(rest, token);
           break;
         case "--link-base":
-          linkBaseUrl = requireValue10(rest, token);
+          linkBaseUrl = requireValue11(rest, token);
           break;
         default:
           throw new Error(`Unknown quiz view option: ${token}`);
@@ -21150,22 +21459,22 @@ function parseQuizArgs(tokens) {
       const token = rest.shift();
       switch (token) {
         case "--paper-id":
-          paperId = requireValue10(rest, token);
+          paperId = requireValue11(rest, token);
           break;
         case "--step-id":
-          stepId = requireValue10(rest, token);
+          stepId = requireValue11(rest, token);
           break;
         case "--file":
-          filePath = requireValue10(rest, token);
+          filePath = requireValue11(rest, token);
           break;
         case "--new-paper-id":
-          newPaperId = requireValue10(rest, token);
+          newPaperId = requireValue11(rest, token);
           break;
         case "--base-url":
-          apiBaseUrl = requireValue10(rest, token);
+          apiBaseUrl = requireValue11(rest, token);
           break;
         case "--link-base":
-          linkBaseUrl = requireValue10(rest, token);
+          linkBaseUrl = requireValue11(rest, token);
           break;
         case "--activate":
           activate = true;
@@ -21255,10 +21564,10 @@ function parseLinearPrArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--account":
-        account = requireValue10(rest, token);
+        account = requireValue11(rest, token);
         break;
       case "--cwd":
-        cwd = requireValue10(rest, token);
+        cwd = requireValue11(rest, token);
         break;
       default:
         throw new Error(`Unknown linear option: ${token}`);
@@ -21287,35 +21596,35 @@ function parseLinearCreateArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--account":
-        account = requireValue10(rest, token);
+        account = requireValue11(rest, token);
         break;
       case "--repl":
         useRepl = true;
         break;
       case "--title":
-        title = requireValue10(rest, token);
+        title = requireValue11(rest, token);
         break;
       case "--desc":
       case "--description":
-        description = decodeEscapedNewlines(requireValue10(rest, token));
+        description = decodeEscapedNewlines(requireValue11(rest, token));
         break;
       case "--team-id":
-        teamId = requireValue10(rest, token);
+        teamId = requireValue11(rest, token);
         break;
       case "--team-key":
-        teamKey = requireValue10(rest, token);
+        teamKey = requireValue11(rest, token);
         break;
       case "--priority":
-        priority = parseLinearPriority(requireValue10(rest, token));
+        priority = parseLinearPriority(requireValue11(rest, token));
         break;
       case "--parent-id":
-        parentId = requireValue10(rest, token);
+        parentId = requireValue11(rest, token);
         break;
       case "--state-id":
-        stateId = requireValue10(rest, token);
+        stateId = requireValue11(rest, token);
         break;
       case "--cwd":
-        cwd = requireValue10(rest, token);
+        cwd = requireValue11(rest, token);
         break;
       default:
         throw new Error(`Unknown linear option: ${token}`);
@@ -21350,10 +21659,10 @@ function parseLinearWhoamiArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--account":
-        account = requireValue10(rest, token);
+        account = requireValue11(rest, token);
         break;
       case "--cwd":
-        cwd = requireValue10(rest, token);
+        cwd = requireValue11(rest, token);
         break;
       default:
         throw new Error(`Unknown linear option: ${token}`);
@@ -21378,10 +21687,10 @@ function parseLinearViewArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--account":
-        account = requireValue10(rest, token);
+        account = requireValue11(rest, token);
         break;
       case "--cwd":
-        cwd = requireValue10(rest, token);
+        cwd = requireValue11(rest, token);
         break;
       default:
         throw new Error(`Unknown linear option: ${token}`);
@@ -21416,32 +21725,32 @@ function parseLinearUpdateArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--account":
-        account = requireValue10(rest, token);
+        account = requireValue11(rest, token);
         break;
       case "--title":
-        title = requireValue10(rest, token);
+        title = requireValue11(rest, token);
         break;
       case "--desc":
       case "--description":
-        description = decodeEscapedNewlines(requireValue10(rest, token));
+        description = decodeEscapedNewlines(requireValue11(rest, token));
         break;
       case "--team-id":
-        teamId = requireValue10(rest, token);
+        teamId = requireValue11(rest, token);
         break;
       case "--team-key":
-        teamKey = requireValue10(rest, token);
+        teamKey = requireValue11(rest, token);
         break;
       case "--priority":
-        priority = parseLinearPriority(requireValue10(rest, token));
+        priority = parseLinearPriority(requireValue11(rest, token));
         break;
       case "--parent-id":
-        parentId = requireValue10(rest, token);
+        parentId = requireValue11(rest, token);
         break;
       case "--state-id":
-        stateId = requireValue10(rest, token);
+        stateId = requireValue11(rest, token);
         break;
       case "--cwd":
-        cwd = requireValue10(rest, token);
+        cwd = requireValue11(rest, token);
         break;
       default:
         throw new Error(`Unknown linear option: ${token}`);
@@ -21479,10 +21788,10 @@ function parseLinearSubIssuesArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--account":
-        account = requireValue10(rest, token);
+        account = requireValue11(rest, token);
         break;
       case "--cwd":
-        cwd = requireValue10(rest, token);
+        cwd = requireValue11(rest, token);
         break;
       default:
         throw new Error(`Unknown linear option: ${token}`);
@@ -21509,15 +21818,15 @@ function parseLinearCommentArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--account":
-        account = requireValue10(rest, token);
+        account = requireValue11(rest, token);
         break;
       case "--body":
       case "--desc":
       case "--description":
-        body = decodeEscapedNewlines(requireValue10(rest, token));
+        body = decodeEscapedNewlines(requireValue11(rest, token));
         break;
       case "--cwd":
-        cwd = requireValue10(rest, token);
+        cwd = requireValue11(rest, token);
         break;
       default:
         throw new Error(`Unknown linear option: ${token}`);
@@ -21547,10 +21856,10 @@ function parseLinearCommentsArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--account":
-        account = requireValue10(rest, token);
+        account = requireValue11(rest, token);
         break;
       case "--cwd":
-        cwd = requireValue10(rest, token);
+        cwd = requireValue11(rest, token);
         break;
       default:
         throw new Error(`Unknown linear option: ${token}`);
@@ -21574,16 +21883,16 @@ function parseLinearCycleArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--account":
-        account = requireValue10(rest, token);
+        account = requireValue11(rest, token);
         break;
       case "--team-id":
-        teamId = requireValue10(rest, token);
+        teamId = requireValue11(rest, token);
         break;
       case "--team-key":
-        teamKey = requireValue10(rest, token);
+        teamKey = requireValue11(rest, token);
         break;
       case "--cwd":
-        cwd = requireValue10(rest, token);
+        cwd = requireValue11(rest, token);
         break;
       default:
         throw new Error(`Unknown linear option: ${token}`);
@@ -21606,10 +21915,10 @@ function parseLinearTeamsArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--account":
-        account = requireValue10(rest, token);
+        account = requireValue11(rest, token);
         break;
       case "--cwd":
-        cwd = requireValue10(rest, token);
+        cwd = requireValue11(rest, token);
         break;
       default:
         throw new Error(`Unknown linear option: ${token}`);
@@ -21636,16 +21945,16 @@ function parseLinearUserIssuesArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--account":
-        account = requireValue10(rest, token);
+        account = requireValue11(rest, token);
         break;
       case "--cycle":
-        cycle = parseLinearCycle(requireValue10(rest, token));
+        cycle = parseLinearCycle(requireValue11(rest, token));
         break;
       case "--status":
-        status = parseLinearStatus(requireValue10(rest, token));
+        status = parseLinearStatus(requireValue11(rest, token));
         break;
       case "--cwd":
-        cwd = requireValue10(rest, token);
+        cwd = requireValue11(rest, token);
         break;
       default:
         throw new Error(`Unknown linear option: ${token}`);
@@ -21679,28 +21988,28 @@ function parseLinearIssuesArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--account":
-        account = requireValue10(rest, token);
+        account = requireValue11(rest, token);
         break;
       case "--team-id":
-        teamId = requireValue10(rest, token);
+        teamId = requireValue11(rest, token);
         break;
       case "--team-key":
-        teamKey = requireValue10(rest, token);
+        teamKey = requireValue11(rest, token);
         break;
       case "--user":
-        user = requireValue10(rest, token);
+        user = requireValue11(rest, token);
         break;
       case "--cycle":
-        cycle = parseLinearCycle(requireValue10(rest, token));
+        cycle = parseLinearCycle(requireValue11(rest, token));
         break;
       case "--status":
-        status = parseLinearStatus(requireValue10(rest, token));
+        status = parseLinearStatus(requireValue11(rest, token));
         break;
       case "--query":
-        query = requireValue10(rest, token).trim();
+        query = requireValue11(rest, token).trim();
         break;
       case "--limit": {
-        const value = Number.parseInt(requireValue10(rest, token), 10);
+        const value = Number.parseInt(requireValue11(rest, token), 10);
         if (!Number.isInteger(value) || value < 1 || value > 250) {
           throw new Error("Invalid --limit. Expected an integer between 1 and 250.");
         }
@@ -21708,7 +22017,7 @@ function parseLinearIssuesArgs(tokens) {
         break;
       }
       case "--cwd":
-        cwd = requireValue10(rest, token);
+        cwd = requireValue11(rest, token);
         break;
       default:
         throw new Error(`Unknown linear option: ${token}`);
@@ -21749,10 +22058,10 @@ function parseLinearLegacyArgs(tokens) {
         useScreenshot = true;
         break;
       case "--account":
-        account = requireValue10(rest, token);
+        account = requireValue11(rest, token);
         break;
       case "--cwd":
-        cwd = requireValue10(rest, token);
+        cwd = requireValue11(rest, token);
         break;
       default:
         throw new Error(`Unknown linear option: ${token}`);
@@ -21846,19 +22155,19 @@ function parseNotionArgs(tokens) {
       const token = rest.shift();
       switch (token) {
         case "--parent":
-          parentPageId = requireValue10(rest, token);
+          parentPageId = requireValue11(rest, token);
           break;
         case "--title":
-          title = requireValue10(rest, token);
+          title = requireValue11(rest, token);
           break;
         case "--private":
           isPrivate = true;
           break;
         case "--content":
-          content2 = requireValue10(rest, token);
+          content2 = requireValue11(rest, token);
           break;
         case "--file":
-          filePath2 = requireValue10(rest, token);
+          filePath2 = requireValue11(rest, token);
           break;
         default:
           throw new Error(`Unknown notion option: ${token}`);
@@ -21902,10 +22211,10 @@ function parseNotionArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--content":
-        content = requireValue10(rest, token);
+        content = requireValue11(rest, token);
         break;
       case "--file":
-        filePath = requireValue10(rest, token);
+        filePath = requireValue11(rest, token);
         break;
       case "--append":
         append = true;
@@ -21950,11 +22259,11 @@ function parseRandomArgs(tokens) {
         mode = "easy";
         break;
       case "--length":
-        length = parsePositiveInt(requireValue10(rest, token), token);
+        length = parsePositiveInt(requireValue11(rest, token), token);
         seenLength = true;
         break;
       case "--charset": {
-        const value = requireValue10(rest, token);
+        const value = requireValue11(rest, token);
         if (!["base64url", "hex", "alnum", "ascii"].includes(value)) {
           throw new Error(
             `Invalid --charset value: ${value}. Use base64url|hex|alnum|ascii.`
@@ -21965,18 +22274,18 @@ function parseRandomArgs(tokens) {
         break;
       }
       case "--count":
-        count = parsePositiveInt(requireValue10(rest, token), token);
+        count = parsePositiveInt(requireValue11(rest, token), token);
         break;
       case "--words":
-        words = parsePositiveInt(requireValue10(rest, token), token);
+        words = parsePositiveInt(requireValue11(rest, token), token);
         seenWords = true;
         break;
       case "--digits":
-        digits = parseNonNegativeInt(requireValue10(rest, token), token);
+        digits = parseNonNegativeInt(requireValue11(rest, token), token);
         seenDigits = true;
         break;
       case "--separator":
-        separator = requireValue10(rest, token);
+        separator = requireValue11(rest, token);
         seenSeparator = true;
         break;
       default:
@@ -22007,7 +22316,7 @@ function parseRandomArgs(tokens) {
     count
   };
 }
-function requireValue10(tokens, optionName) {
+function requireValue11(tokens, optionName) {
   const value = tokens.shift();
   if (!value) {
     throw new Error(`Missing value for ${optionName}`);
@@ -22083,6 +22392,11 @@ async function main() {
         await handler.handle(commandArgs);
         return;
       }
+      case "prepare-dev" /* PrepareDev */: {
+        const handler = new PrepareDevCommandHandler();
+        await handler.handle(commandArgs);
+        return;
+      }
       case "env" /* Env */: {
         const handler = new EnvCommandHandler();
         await handler.handle(commandArgs);