opendevbrowser 0.0.26 → 0.0.27

package/dist/cli/index.js

@@ -41,7 +41,7 @@ import {
   resolveExitCode,
   startDaemon,
   toCliError
-} from "../chunk-GTTYIAI7.js";
+} from "../chunk-MWBDO2L5.js";
 import "../chunk-STGGGVYT.js";
 import {
   createNoOpSkillRemovalResult,
@@ -74,7 +74,7 @@ import {
   setDefaultLogSink,
   stderrSink,
   summarizePrimaryProviderIssue
-} from "../chunk-AVQL6WAS.js";
+} from "../chunk-V5DJUSPV.js";
 import "../chunk-FUSXMW3G.js";
 
 // src/cli/args.ts
@@ -143,6 +143,17 @@ function parseTransport(args) {
 }
 var VALID_FLAG_SET = new Set(VALID_FLAGS);
 var VALID_EQUALS_FLAG_SET = new Set(VALID_EQUALS_FLAGS);
+var SIGNED_VALUE_FLAG_SET = /* @__PURE__ */ new Set(["--dy"]);
+var SIGNED_INTEGER_VALUE = /^-\d+$/;
+function shouldSkipValueToken(flag, value) {
+  if (!VALID_EQUALS_FLAG_SET.has(flag) || value === void 0) {
+    return false;
+  }
+  if (!value.startsWith("-")) {
+    return true;
+  }
+  return SIGNED_VALUE_FLAG_SET.has(flag) && SIGNED_INTEGER_VALUE.test(value);
+}
 function parseArgs(argv) {
   let args = expandShortFlags(argv.slice(2));
   let commandOverride = null;
@@ -237,7 +248,8 @@ function parseArgs(argv) {
   } else if (noPrompt) {
     mode = "global";
   }
-  for (const arg of args) {
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index] ?? "";
     if (arg.startsWith("--") && !VALID_FLAG_SET.has(arg)) {
       if (arg.includes("=")) {
         const baseFlag = arg.split("=", 2)[0] ?? "";
@@ -250,6 +262,9 @@ function parseArgs(argv) {
     if (arg.startsWith("-") && !arg.startsWith("--") && !SHORT_FLAGS[arg]) {
       throw createUsageError(`Unknown flag: ${arg}`);
     }
+    if (shouldSkipValueToken(arg, args[index + 1])) {
+      index += 1;
+    }
   }
   return {
     command: commandOverride ?? "install",
@@ -929,45 +944,292 @@ function installLocal(withConfig = false) {
 import * as fs4 from "fs";
 import * as path2 from "path";
 import * as os2 from "os";
+import { randomUUID } from "crypto";
 var PLUGIN_NAME = "opendevbrowser";
+var CACHE_MANIFEST = "package.json";
+var CACHE_LOCKFILE = "package-lock.json";
+var CACHE_UPDATE_LOCK = ".opendevbrowser-update.lock";
+var CACHE_LOCK_STALE_MS = 30 * 60 * 1e3;
+var DEPENDENCY_SECTIONS = [
+  "dependencies",
+  "devDependencies",
+  "optionalDependencies",
+  "peerDependencies"
+];
 function getCacheDir() {
   return process.env.OPENCODE_CACHE_DIR || path2.join(os2.homedir(), ".cache", "opencode");
 }
-function rmdir(dirPath) {
-  const cacheDir = getCacheDir();
+function assertCacheChild(targetPath, cacheDir) {
+  const resolvedCache = path2.resolve(cacheDir);
+  const resolvedPath = path2.resolve(targetPath);
+  const relativePath = path2.relative(resolvedCache, resolvedPath);
+  if (!relativePath || relativePath.startsWith("..") || path2.isAbsolute(relativePath)) {
+    throw new Error(`Security: refusing to modify path outside cache directory: ${targetPath}`);
+  }
+}
+function isMissingPathError(error) {
+  return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+function isExistingPathError(error) {
+  return error instanceof Error && "code" in error && error.code === "EEXIST";
+}
+function assertNoSymlinkCachePath(targetPath, cacheDir) {
+  assertCacheChild(targetPath, cacheDir);
   const resolvedCache = path2.resolve(cacheDir);
-  const resolvedPath = path2.resolve(dirPath);
-  if (!resolvedPath.startsWith(resolvedCache + path2.sep) || resolvedPath === resolvedCache) {
-    throw new Error(`Security: refusing to delete path outside cache directory: ${dirPath}`);
+  const relativeSegments = path2.relative(resolvedCache, path2.resolve(targetPath)).split(path2.sep).filter(Boolean);
+  for (const candidate of [resolvedCache, ...relativeSegments.map((_, index) => path2.join(resolvedCache, ...relativeSegments.slice(0, index + 1)))]) {
+    try {
+      if (fs4.lstatSync(candidate).isSymbolicLink()) {
+        throw new Error(`Security: refusing to modify symlinked cache path: ${candidate}`);
+      }
+    } catch (error) {
+      if (isMissingPathError(error)) {
+        continue;
+      }
+      throw error;
+    }
+  }
+}
+function cacheDirectoryExists(cacheDir) {
+  try {
+    const stat = fs4.lstatSync(cacheDir);
+    if (stat.isSymbolicLink()) {
+      throw new Error(`Security: refusing to modify symlinked cache path: ${cacheDir}`);
+    }
+    if (!stat.isDirectory()) {
+      throw new Error(`${cacheDir} must be a directory`);
+    }
+    return true;
+  } catch (error) {
+    if (isMissingPathError(error)) {
+      return false;
+    }
+    throw error;
+  }
+}
+function removePathIfExists(targetPath, cacheDir) {
+  assertNoSymlinkCachePath(targetPath, cacheDir);
+  if (!fs4.existsSync(targetPath)) {
+    return false;
+  }
+  fs4.rmSync(targetPath, { recursive: true, force: true });
+  return true;
+}
+function cacheFileExists(targetPath, cacheDir) {
+  assertNoSymlinkCachePath(targetPath, cacheDir);
+  try {
+    const stat = fs4.lstatSync(targetPath);
+    if (stat.isSymbolicLink()) {
+      throw new Error(`Security: refusing to modify symlinked cache manifest: ${targetPath}`);
+    }
+    return stat.isFile();
+  } catch (error) {
+    if (isMissingPathError(error)) {
+      return false;
+    }
+    throw error;
+  }
+}
+function writeManifestAtomic(manifestPath, cacheDir, manifest) {
+  const tempPath = `${manifestPath}.${process.pid}.tmp`;
+  assertNoSymlinkCachePath(tempPath, cacheDir);
+  let fd = null;
+  try {
+    fd = fs4.openSync(tempPath, "wx");
+    fs4.writeFileSync(fd, `${JSON.stringify(manifest, null, 2)}
+`, "utf8");
+    fs4.closeSync(fd);
+    fd = null;
+    fs4.renameSync(tempPath, manifestPath);
+  } catch (error) {
+    if (fd !== null) {
+      fs4.closeSync(fd);
+    }
+    fs4.rmSync(tempPath, { force: true });
+    throw error;
+  }
+}
+function withCacheMutationLock(cacheDir, action) {
+  const lockPath = path2.join(cacheDir, CACHE_UPDATE_LOCK);
+  assertNoSymlinkCachePath(lockPath, cacheDir);
+  let lock = null;
+  try {
+    lock = openCacheMutationLock(lockPath);
+    return action();
+  } catch (error) {
+    if (isExistingPathError(error)) {
+      throw new Error("another update is already running for this OpenCode cache");
+    }
+    throw error;
+  } finally {
+    if (lock !== null) {
+      fs4.closeSync(lock.fd);
+      removeOwnedCacheMutationLock(lockPath, lock.token);
+    }
+  }
+}
+function openCacheMutationLock(lockPath) {
+  try {
+    return writeCacheMutationLock(lockPath);
+  } catch (error) {
+    if (!isExistingPathError(error) || !isStaleCacheMutationLock(lockPath)) {
+      throw error;
+    }
+    removeStaleCacheMutationLock(lockPath);
+    return writeCacheMutationLock(lockPath);
+  }
+}
+function writeCacheMutationLock(lockPath) {
+  const fd = fs4.openSync(lockPath, "wx");
+  const token = randomUUID();
+  try {
+    const lock = { pid: process.pid, createdAt: Date.now(), token };
+    fs4.writeFileSync(fd, `${JSON.stringify(lock)}
+`, "utf8");
+    return { fd, token };
+  } catch (error) {
+    fs4.closeSync(fd);
+    fs4.rmSync(lockPath, { force: true });
+    throw error;
+  }
+}
+function isStaleCacheMutationLock(lockPath) {
+  const lock = readCacheMutationLock(lockPath);
+  if (!lock) {
+    return isLegacyCacheMutationLockStale(lockPath);
   }
-  if (fs4.existsSync(dirPath)) {
-    fs4.rmSync(dirPath, { recursive: true, force: true });
+  if (Date.now() - lock.createdAt < CACHE_LOCK_STALE_MS) {
+    return false;
+  }
+  return !isProcessRunning(lock.pid);
+}
+function isLegacyCacheMutationLockStale(lockPath) {
+  try {
+    const pid = readLegacyCacheMutationLockPid(lockPath);
+    if (pid !== null && isProcessRunning(pid)) {
+      return false;
+    }
+    return Date.now() - fs4.statSync(lockPath).mtimeMs >= CACHE_LOCK_STALE_MS;
+  } catch {
+    return false;
   }
 }
+function readLegacyCacheMutationLockPid(lockPath) {
+  const raw = fs4.readFileSync(lockPath, "utf8").trim();
+  if (!/^\d+$/.test(raw)) {
+    return null;
+  }
+  const pid = Number(raw);
+  return Number.isSafeInteger(pid) && pid > 0 ? pid : null;
+}
+function readCacheMutationLock(lockPath) {
+  try {
+    const parsed = JSON.parse(fs4.readFileSync(lockPath, "utf8"));
+    const { pid, createdAt, token } = parsed;
+    const hasToken = token === void 0 || typeof token === "string" && token.length > 0;
+    if (typeof pid === "number" && typeof createdAt === "number" && hasToken && Number.isInteger(pid) && Number.isFinite(createdAt)) {
+      return token === void 0 ? { pid, createdAt } : { pid, createdAt, token };
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+function isProcessRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error instanceof Error && "code" in error && error.code === "EPERM";
+  }
+}
+function createExistingLockError() {
+  const error = new Error("cache update lock changed before stale cleanup");
+  error.code = "EEXIST";
+  return error;
+}
+function removeStaleCacheMutationLock(lockPath) {
+  const content = fs4.readFileSync(lockPath, "utf8");
+  if (!isStaleCacheMutationLock(lockPath) || fs4.readFileSync(lockPath, "utf8") !== content) {
+    throw createExistingLockError();
+  }
+  fs4.rmSync(lockPath, { force: true });
+}
+function removeOwnedCacheMutationLock(lockPath, token) {
+  const lock = readCacheMutationLock(lockPath);
+  if (lock?.token === token) {
+    fs4.rmSync(lockPath, { force: true });
+  }
+}
+function preflightCacheMutationPaths(cacheDir, paths) {
+  for (const targetPath of paths) {
+    assertNoSymlinkCachePath(targetPath, cacheDir);
+  }
+}
+function isJsonObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function removeDependencyPin(manifest, section) {
+  const dependencies = manifest[section];
+  if (!isJsonObject(dependencies) || !(PLUGIN_NAME in dependencies)) {
+    return false;
+  }
+  delete dependencies[PLUGIN_NAME];
+  if (Object.keys(dependencies).length === 0) {
+    delete manifest[section];
+  }
+  return true;
+}
+function removeManifestPin(cacheDir) {
+  const manifestPath = path2.join(cacheDir, CACHE_MANIFEST);
+  if (!cacheFileExists(manifestPath, cacheDir)) {
+    return false;
+  }
+  const manifest = JSON.parse(fs4.readFileSync(manifestPath, "utf8"));
+  if (!isJsonObject(manifest)) {
+    throw new Error(`${CACHE_MANIFEST} must contain a JSON object`);
+  }
+  const removed = DEPENDENCY_SECTIONS.map((section) => removeDependencyPin(manifest, section)).some(Boolean);
+  if (removed) {
+    writeManifestAtomic(manifestPath, cacheDir, manifest);
+  }
+  return removed;
+}
 function runUpdate() {
   const cacheDir = getCacheDir();
   const nodeModulesDir = path2.join(cacheDir, "node_modules");
   const pluginCacheDir = path2.join(nodeModulesDir, PLUGIN_NAME);
+  const lockfilePath = path2.join(cacheDir, CACHE_LOCKFILE);
   try {
-    if (!fs4.existsSync(pluginCacheDir)) {
-      if (fs4.existsSync(nodeModulesDir)) {
-        rmdir(nodeModulesDir);
-        return {
-          success: true,
-          message: "Cleared OpenCode plugin cache. The latest version will be installed on next run.",
-          cleared: true
-        };
-      }
+    if (!cacheDirectoryExists(cacheDir)) {
+      return {
+        success: true,
+        message: "No cached plugin found. OpenCode will install the latest version on next run.",
+        cleared: false
+      };
+    }
+    preflightCacheMutationPaths(cacheDir, [
+      path2.join(cacheDir, CACHE_MANIFEST),
+      pluginCacheDir,
+      lockfilePath,
+      path2.join(cacheDir, CACHE_UPDATE_LOCK)
+    ]);
+    const cleared = withCacheMutationLock(cacheDir, () => {
+      const manifestPinRemoved = removeManifestPin(cacheDir);
+      const packageRemoved = removePathIfExists(pluginCacheDir, cacheDir);
+      const lockfileRemoved = removePathIfExists(lockfilePath, cacheDir);
+      return packageRemoved || manifestPinRemoved || lockfileRemoved;
+    });
+    if (!cleared) {
       return {
         success: true,
         message: "No cached plugin found. OpenCode will install the latest version on next run.",
         cleared: false
       };
     }
-    rmdir(pluginCacheDir);
     return {
       success: true,
-      message: "Cache cleared. OpenCode will install the latest version on next run.",
+      message: "Cache repaired. OpenCode will install the latest version on next run.",
       cleared: true
     };
   } catch (error) {
@@ -1056,7 +1318,24 @@ function findInstalledConfigs() {
 import { spawnSync } from "child_process";
 
 // src/cli/utils/parse.ts
+var SIGNED_INTEGER_PATTERN = /^-?\d+$/;
+var UNSIGNED_INTEGER_PATTERN = /^\d+$/;
+var SIGNED_DECIMAL_PATTERN = /^-?(?:\d+|\d+\.\d+|\.\d+)$/;
+var UNSIGNED_DECIMAL_PATTERN = /^(?:\d+|\d+\.\d+|\.\d+)$/;
+function allowsNegative(options) {
+  return typeof options.min !== "number" || options.min < 0;
+}
+function decimalPattern(options) {
+  const signed = allowsNegative(options);
+  if (options.integer ?? true) {
+    return signed ? SIGNED_INTEGER_PATTERN : UNSIGNED_INTEGER_PATTERN;
+  }
+  return signed ? SIGNED_DECIMAL_PATTERN : UNSIGNED_DECIMAL_PATTERN;
+}
 function parseNumberFlag(value, flag, options = {}) {
+  if (value.trim() === "" || value !== value.trim() || !decimalPattern(options).test(value)) {
+    throw createUsageError(`Invalid ${flag}: ${value}`);
+  }
   const parsed = Number(value);
   if (!Number.isFinite(parsed)) {
     throw createUsageError(`Invalid ${flag}: ${value}`);
@@ -1927,9 +2206,9 @@ ${nativeMessage}${staleNote}` : `${baseMessage}${staleNote}`;
 
 // src/cli/daemon-autostart.ts
 import { execFileSync as execFileSync2 } from "child_process";
-import { existsSync as existsSync5, mkdirSync as mkdirSync2, unlinkSync as unlinkSync2, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync5, mkdirSync as mkdirSync2, statSync as statSync2, unlinkSync as unlinkSync2, writeFileSync as writeFileSync5 } from "fs";
 import { homedir as homedir4, tmpdir } from "os";
-import { dirname as dirname3, isAbsolute, join as join5, relative, resolve as resolve3 } from "path";
+import { dirname as dirname3, isAbsolute as isAbsolute2, join as join5, relative as relative2, resolve as resolve3 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var MAC_LABEL = "com.opendevbrowser.daemon";
 var WIN_TASK_NAME = "OpenDevBrowser Daemon";
@@ -1942,7 +2221,8 @@ var defaultDeps = () => ({
   homedir: homedir4,
   existsSync: existsSync5,
   mkdirSync: mkdirSync2,
-  writeFileSync: writeFileSync4,
+  statSync: statSync2,
+  writeFileSync: writeFileSync5,
   unlinkSync: unlinkSync2,
   execFileSync: execFileSync2,
   transientEntrypointRoots: void 0
@@ -1951,6 +2231,17 @@ var NPX_CACHE_SEGMENT_PATTERN = /[\\/]_npx(?:[\\/]|$)/;
 var formatCommand = (programArguments) => {
   return programArguments.map((value) => `"${value}"`).join(" ");
 };
+var resolveMacWorkingDirectory = (home) => {
+  return join5(home, ".cache", "opendevbrowser");
+};
+var pathIsDirectory = (path5, deps) => {
+  if (!deps.existsSync(path5)) return false;
+  try {
+    return deps.statSync(path5).isDirectory();
+  } catch {
+    return false;
+  }
+};
 var resolveCliPathFromModule = (moduleUrl, exists) => {
   const modulePath = fileURLToPath2(moduleUrl);
   const candidate = resolve3(dirname3(modulePath), "..", "index.js");
@@ -1966,8 +2257,8 @@ var normalizeComparisonPath = (value, platform) => {
 var isPathInsideRoot = (candidate, root, platform) => {
   const normalizedCandidate = normalizeComparisonPath(candidate, platform);
   const normalizedRoot = normalizeComparisonPath(root, platform);
-  const relation = relative(normalizedRoot, normalizedCandidate);
-  return relation === "" || !relation.startsWith("..") && !isAbsolute(relation);
+  const relation = relative2(normalizedRoot, normalizedCandidate);
+  return relation === "" || !relation.startsWith("..") && !isAbsolute2(relation);
 };
 var getTransientEntrypointRoots = (deps) => {
   const configuredRoots = deps.transientEntrypointRoots;
@@ -2013,18 +2304,20 @@ var resolveCliEntrypoint = (deps = {}) => {
 var getLaunchAgentPath = (home = homedir4()) => {
   return join5(home, "Library", "LaunchAgents", `${MAC_LABEL}.plist`);
 };
+var escapePlistString = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
 var buildLaunchAgentPlist = (entrypoint, options = {}) => {
   const label = options.label ?? MAC_LABEL;
   const stdoutPath = options.stdoutPath ?? join5(homedir4(), "Library", "Logs", "opendevbrowser-daemon.log");
   const stderrPath = options.stderrPath ?? join5(homedir4(), "Library", "Logs", "opendevbrowser-daemon.err.log");
-  const programArgs = [entrypoint.nodePath, ...entrypoint.args].map((value) => `      <string>${value}</string>`).join("\n");
+  const workingDirectory = options.workingDirectory ?? resolveMacWorkingDirectory(homedir4());
+  const programArgs = [entrypoint.nodePath, ...entrypoint.args].map((value) => `      <string>${escapePlistString(value)}</string>`).join("\n");
   return [
     '<?xml version="1.0" encoding="UTF-8"?>',
     '<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">',
     '<plist version="1.0">',
     "<dict>",
     `  <key>Label</key>`,
-    `  <string>${label}</string>`,
+    `  <string>${escapePlistString(label)}</string>`,
     "  <key>ProgramArguments</key>",
     "  <array>",
     programArgs,
@@ -2033,10 +2326,12 @@ var buildLaunchAgentPlist = (entrypoint, options = {}) => {
     "  <true/>",
     "  <key>KeepAlive</key>",
     "  <true/>",
+    "  <key>WorkingDirectory</key>",
+    `  <string>${escapePlistString(workingDirectory)}</string>`,
     "  <key>StandardOutPath</key>",
-    `  <string>${stdoutPath}</string>`,
+    `  <string>${escapePlistString(stdoutPath)}</string>`,
     "  <key>StandardErrorPath</key>",
-    `  <string>${stderrPath}</string>`,
+    `  <string>${escapePlistString(stderrPath)}</string>`,
     "</dict>",
     "</plist>",
     ""
@@ -2128,6 +2423,7 @@ var readMacLaunchAgentProgramArguments = (plistPath, deps) => {
     const text = deps.execFileSync("plutil", ["-convert", "json", "-o", "-", plistPath], { encoding: "utf-8" });
     const parsed = JSON.parse(text);
     const programArguments = parsed?.ProgramArguments;
+    const workingDirectory = typeof parsed?.WorkingDirectory === "string" ? parsed.WorkingDirectory : void 0;
     if (!Array.isArray(programArguments) || programArguments.length < 2 || programArguments.some((value) => typeof value !== "string")) {
       return { ok: false, reason: "missing_program_arguments" };
     }
@@ -2135,7 +2431,8 @@ var readMacLaunchAgentProgramArguments = (plistPath, deps) => {
     return {
       ok: true,
       command: formatCommand(commandArgs),
-      programArguments: commandArgs
+      programArguments: commandArgs,
+      ...workingDirectory ? { workingDirectory } : {}
     };
   } catch {
     return { ok: false, reason: "malformed_plist" };
@@ -2151,11 +2448,13 @@ var classifyMacAutostartStatus = (entrypoint, location, deps) => {
     });
   }
   const parsed = readMacLaunchAgentProgramArguments(location, deps);
+  const expectedWorkingDirectory = resolveMacWorkingDirectory(deps.homedir());
   if (!parsed.ok) {
     return createMacAutostartStatus(entrypoint, location, {
       installed: true,
       health: "malformed",
       needsRepair: true,
+      expectedWorkingDirectory,
       reason: parsed.reason
     });
   }
@@ -2170,15 +2469,41 @@ var classifyMacAutostartStatus = (entrypoint, location, deps) => {
       health: "needs_repair",
       needsRepair: true,
       command: parsed.command,
+      workingDirectory: parsed.workingDirectory,
+      expectedWorkingDirectory,
       reason: actualStatus.reason
     });
   }
+  if (parsed.workingDirectory !== expectedWorkingDirectory) {
+    return createMacAutostartStatus(entrypoint, location, {
+      installed: true,
+      health: "needs_repair",
+      needsRepair: true,
+      command: parsed.command,
+      workingDirectory: parsed.workingDirectory,
+      expectedWorkingDirectory,
+      reason: "working_directory_mismatch"
+    });
+  }
+  if (!pathIsDirectory(expectedWorkingDirectory, deps)) {
+    return createMacAutostartStatus(entrypoint, location, {
+      installed: true,
+      health: "needs_repair",
+      needsRepair: true,
+      command: parsed.command,
+      workingDirectory: parsed.workingDirectory,
+      expectedWorkingDirectory,
+      reason: "working_directory_mismatch"
+    });
+  }
   if (entrypoint.isTransient) {
     return createMacAutostartStatus(entrypoint, location, {
       installed: true,
       health: "healthy",
       needsRepair: false,
-      command: parsed.command
+      command: parsed.command,
+      workingDirectory: parsed.workingDirectory,
+      expectedWorkingDirectory
     });
   }
   const mismatchReason = classifyExpectedProgramArguments(expectedArgs, actualArgs, deps);
@@ -2188,6 +2513,8 @@ var classifyMacAutostartStatus = (entrypoint, location, deps) => {
       health: "needs_repair",
       needsRepair: true,
       command: parsed.command,
+      workingDirectory: parsed.workingDirectory,
+      expectedWorkingDirectory,
       reason: mismatchReason
     });
   }
@@ -2195,7 +2522,9 @@ var classifyMacAutostartStatus = (entrypoint, location, deps) => {
     installed: true,
     health: "healthy",
     needsRepair: false,
-    command: parsed.command
+    command: parsed.command,
+    workingDirectory: parsed.workingDirectory,
+    expectedWorkingDirectory
   });
 };
 var runCommand = (exec, command, args, ignoreFailure = false) => {
@@ -2223,12 +2552,14 @@ var installMacAutostart = (deps = {}) => {
   const plistPath = getLaunchAgentPath(home);
   const stdoutPath = join5(home, "Library", "Logs", "opendevbrowser-daemon.log");
   const stderrPath = join5(home, "Library", "Logs", "opendevbrowser-daemon.err.log");
+  const workingDirectory = resolveMacWorkingDirectory(home);
   const logsDir = dirname3(stdoutPath);
   resolved.mkdirSync(dirname3(plistPath), { recursive: true });
   resolved.mkdirSync(logsDir, { recursive: true });
+  resolved.mkdirSync(workingDirectory, { recursive: true });
   resolved.writeFileSync(
     plistPath,
-    buildLaunchAgentPlist(entrypoint, { stdoutPath, stderrPath }),
+    buildLaunchAgentPlist(entrypoint, { stdoutPath, stderrPath, workingDirectory }),
     { encoding: "utf-8" }
   );
   const uid = resolved.uid;
@@ -2240,7 +2571,9 @@ var installMacAutostart = (deps = {}) => {
     installed: true,
     health: "healthy",
     needsRepair: false,
-    command: entrypoint.command
+    command: entrypoint.command,
+    workingDirectory,
+    expectedWorkingDirectory: workingDirectory
   });
 };
 var uninstallMacAutostart = (deps = {}) => {
@@ -2832,7 +3165,7 @@ function formatAutostartReconciliationMessage(result) {
 }
 
 // src/cli/commands/run.ts
-import { readFileSync as readFileSync2 } from "fs";
+import { readFileSync as readFileSync3 } from "fs";
 
 // src/cli/output.ts
 var normalizeExitCode = (code) => {
@@ -2996,7 +3329,7 @@ async function runScriptCommand(args) {
   const outputOptions = { format: args.outputFormat, quiet: args.quiet };
   let scriptRaw = "";
   if (runArgs.scriptPath) {
-    scriptRaw = readFileSync2(runArgs.scriptPath, "utf-8");
+    scriptRaw = readFileSync3(runArgs.scriptPath, "utf-8");
   } else if (!process.stdin.isTTY) {
     scriptRaw = await readScriptFromStdin();
   } else {
@@ -3929,12 +4262,12 @@ function parseSnapshotArgs(rawArgs) {
     if (arg === "--max-chars") {
       const value = rawArgs[i + 1];
       if (!value) throw createUsageError("Missing value for --max-chars");
-      parsed.maxChars = Number(value);
+      parsed.maxChars = parseNumberFlag(value, "--max-chars", { min: 1 });
       i += 1;
       continue;
     }
     if (arg?.startsWith("--max-chars=")) {
-      parsed.maxChars = Number(arg.split("=", 2)[1]);
+      parsed.maxChars = parseNumberFlag(arg.split("=", 2)[1] ?? "", "--max-chars", { min: 1 });
       continue;
     }
     if (arg === "--cursor") {
@@ -4193,7 +4526,7 @@ async function runAnnotate(args) {
 }
 
 // src/cli/commands/canvas.ts
-import { readFileSync as readFileSync3 } from "fs";
+import { readFileSync as readFileSync4 } from "fs";
 var DEFAULT_FEEDBACK_STREAM_TIMEOUT_MS = 3e4;
 var isRecord = (value) => {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -4394,7 +4727,7 @@ var resolveCanvasParams = (canvasArgs) => {
   if (hasParamsFile) {
     let raw = "";
     try {
-      raw = readFileSync3(canvasArgs.paramsFile ?? "", "utf8");
+      raw = readFileSync4(canvasArgs.paramsFile ?? "", "utf8");
     } catch (error) {
       const message = error instanceof Error ? error.message : "Unable to read file";
       throw createUsageError(`Invalid --params-file: ${message}`);
@@ -4463,7 +4796,7 @@ async function runCanvas(args) {
 }
 
 // src/cli/commands/rpc.ts
-import { readFileSync as readFileSync4 } from "fs";
+import { readFileSync as readFileSync5 } from "fs";
 var requireValue4 = (value, flag) => {
   if (!value) throw createUsageError(`Missing value for ${flag}`);
   return value;
@@ -4543,7 +4876,7 @@ var resolveRpcParams = (rpcArgs) => {
   if (hasParamsFile) {
     let raw = "";
     try {
-      raw = readFileSync4(rpcArgs.paramsFile ?? "", "utf8");
+      raw = readFileSync5(rpcArgs.paramsFile ?? "", "utf8");
     } catch (error) {
       const message = error instanceof Error ? error.message : "Unable to read file";
       throw createUsageError(`Invalid --params-file: ${message}`);
@@ -4974,12 +5307,12 @@ function parseScrollArgs(rawArgs) {
     if (arg === "--dy") {
       const value = rawArgs[i + 1];
       if (!value) throw createUsageError("Missing value for --dy");
-      parsed.dy = Number(value);
+      parsed.dy = parseNumberFlag(value, "--dy");
       i += 1;
       continue;
     }
     if (arg?.startsWith("--dy=")) {
-      parsed.dy = Number(arg.split("=", 2)[1]);
+      parsed.dy = parseNumberFlag(arg.split("=", 2)[1] ?? "", "--dy");
       continue;
     }
   }
@@ -5475,12 +5808,12 @@ function parseDomHtmlArgs(rawArgs) {
     if (arg === "--max-chars") {
       const value = rawArgs[i + 1];
       if (!value) throw createUsageError("Missing value for --max-chars");
-      parsed.maxChars = Number(value);
+      parsed.maxChars = parseNumberFlag(value, "--max-chars", { min: 1 });
       i += 1;
       continue;
     }
     if (arg?.startsWith("--max-chars=")) {
-      parsed.maxChars = Number(arg.split("=", 2)[1]);
+      parsed.maxChars = parseNumberFlag(arg.split("=", 2)[1] ?? "", "--max-chars", { min: 1 });
       continue;
     }
   }
@@ -5530,12 +5863,12 @@ function parseDomTextArgs(rawArgs) {
     if (arg === "--max-chars") {
       const value = rawArgs[i + 1];
       if (!value) throw createUsageError("Missing value for --max-chars");
-      parsed.maxChars = Number(value);
+      parsed.maxChars = parseNumberFlag(value, "--max-chars", { min: 1 });
       i += 1;
       continue;
     }
     if (arg?.startsWith("--max-chars=")) {
-      parsed.maxChars = Number(arg.split("=", 2)[1]);
+      parsed.maxChars = parseNumberFlag(arg.split("=", 2)[1] ?? "", "--max-chars", { min: 1 });
       continue;
     }
   }
@@ -6050,23 +6383,23 @@ function parseConsolePollArgs(rawArgs) {
     if (arg === "--since-seq") {
       const value = rawArgs[i + 1];
       if (!value) throw createUsageError("Missing value for --since-seq");
-      parsed.sinceSeq = Number(value);
+      parsed.sinceSeq = parseNumberFlag(value, "--since-seq", { min: 0 });
       i += 1;
       continue;
     }
     if (arg?.startsWith("--since-seq=")) {
-      parsed.sinceSeq = Number(arg.split("=", 2)[1]);
+      parsed.sinceSeq = parseNumberFlag(arg.split("=", 2)[1] ?? "", "--since-seq", { min: 0 });
       continue;
     }
     if (arg === "--max") {
       const value = rawArgs[i + 1];
       if (!value) throw createUsageError("Missing value for --max");
-      parsed.max = Number(value);
+      parsed.max = parseNumberFlag(value, "--max", { min: 1 });
       i += 1;
       continue;
     }
     if (arg?.startsWith("--max=")) {
-      parsed.max = Number(arg.split("=", 2)[1]);
+      parsed.max = parseNumberFlag(arg.split("=", 2)[1] ?? "", "--max", { min: 1 });
       continue;
     }
   }
@@ -6098,23 +6431,23 @@ function parseNetworkPollArgs(rawArgs) {
     if (arg === "--since-seq") {
       const value = rawArgs[i + 1];
       if (!value) throw createUsageError("Missing value for --since-seq");
-      parsed.sinceSeq = Number(value);
+      parsed.sinceSeq = parseNumberFlag(value, "--since-seq", { min: 0 });
       i += 1;
       continue;
     }
     if (arg?.startsWith("--since-seq=")) {
-      parsed.sinceSeq = Number(arg.split("=", 2)[1]);
+      parsed.sinceSeq = parseNumberFlag(arg.split("=", 2)[1] ?? "", "--since-seq", { min: 0 });
       continue;
     }
     if (arg === "--max") {
       const value = rawArgs[i + 1];
       if (!value) throw createUsageError("Missing value for --max");
-      parsed.max = Number(value);
+      parsed.max = parseNumberFlag(value, "--max", { min: 1 });
       i += 1;
       continue;
     }
     if (arg?.startsWith("--max=")) {
-      parsed.max = Number(arg.split("=", 2)[1]);
+      parsed.max = parseNumberFlag(arg.split("=", 2)[1] ?? "", "--max", { min: 1 });
       continue;
     }
   }
@@ -6326,7 +6659,7 @@ async function runDesktopAccessibilitySnapshot(args) {
 }
 
 // src/cli/commands/session/cookie-import.ts
-import { readFileSync as readFileSync5 } from "fs";
+import { readFileSync as readFileSync6 } from "fs";
 var requireValue5 = (value, flag) => {
   if (!value) {
     throw createUsageError(`Missing value for ${flag}`);
@@ -6441,7 +6774,7 @@ var resolveCookies = (parsed) => {
   }
   let raw = "";
   try {
-    raw = readFileSync5(parsed.cookiesFile ?? "", "utf8");
+    raw = readFileSync6(parsed.cookiesFile ?? "", "utf8");
   } catch (error) {
     const message = error instanceof Error ? error.message : "Unable to read file";
     throw createUsageError(`Invalid --cookies-file: ${message}`);
@@ -7494,7 +7827,7 @@ async function runInspiredesignCommand(args) {
 // package.json
 var package_default = {
   name: "opendevbrowser",
-  version: "0.0.26",
+  version: "0.0.27",
   description: "Browser automation runtime with snapshot-refs-actions, browser replay screencasts, public read-only desktop observation, and browser-scoped computer-use orchestration",
   type: "module",
   main: "dist/index.js",
@@ -7828,7 +8161,7 @@ async function main() {
     });
     registerCommand({
       name: "update",
-      description: "Clear cached plugin and refresh managed skill packs",
+      description: "Repair cached plugin pins and refresh managed skill packs",
       run: () => buildUpdateCommandResult(args, runUpdate(), {
         resolveUpdateSkillModes,
         hasInstalledConfig,