opendoor-plugin 0.1.0

package/dist/server-plugin.js

@@ -0,0 +1,1047 @@
+// Generated from src/server-plugin.ts. Do not edit directly.
+
+// src/server-plugin.ts
+import { readdir as readdir2 } from "node:fs/promises";
+import { join as join2 } from "node:path";
+
+// src/doorstop-backend.ts
+import { readdir } from "node:fs/promises";
+import { join } from "node:path";
+
+// src/doorstop-contract.ts
+function formatUnknownError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function requireRecord(value, label) {
+  if (!isRecord(value)) throw new Error(`${label} must be an object`);
+  return value;
+}
+function requireArrayValue(value, label) {
+  if (!Array.isArray(value)) throw new Error(`${label} must be an array`);
+  return value;
+}
+function requireString(record, key) {
+  const value = record[key];
+  if (typeof value !== "string") throw new Error(`Expected string field: ${key}`);
+  return value;
+}
+
+// src/doorstop-backend-contract.ts
+var DOORSTOP_RUN_OPERATION = "doorstop.run";
+var DOORSTOP_BASELINE_OPERATION = "doorstop.item-baseline";
+var DOORSTOP_BASELINE_GREP_LIMIT = 20;
+var DOORSTOP_BASELINE_HISTORY_LIMIT = 50;
+var DOORSTOP_BASELINE_BLOB_MAX = 256 * 1024;
+function isValidDoorstopUid(value) {
+  if (value === "") return false;
+  if (!/^[\w.-]+$/.test(value)) return false;
+  if (/^[\w.-]+[-_.][\w]+$/.test(value)) return true;
+  if (/^[\w.-]*\D\d+$/.test(value)) return true;
+  return false;
+}
+function isValidDoorstopItemPath(value) {
+  if (value === "") return false;
+  if (value.length > 256) return false;
+  if (value.startsWith("/")) return false;
+  if (/^[A-Za-z]:/.test(value)) return false;
+  if (value.includes("\\")) return false;
+  if (/[\u0000-\u001f\u007f-\u009f\u2028\u2029]/.test(value)) return false;
+  for (const segment of value.split("/")) {
+    if (segment === "..") return false;
+  }
+  return true;
+}
+function isValidPublishTarget(value) {
+  if (value === "") return false;
+  if (value.startsWith("-")) return false;
+  if (value.startsWith("/")) return false;
+  if (/^[A-Za-z]:/.test(value)) return false;
+  if (value.includes("\\")) return false;
+  for (const segment of value.split("/")) {
+    if (segment === "..") return false;
+  }
+  return true;
+}
+var DOORSTOP_RUN_OPS = /* @__PURE__ */ new Set([
+  "validate",
+  "publish",
+  "review",
+  "clear",
+  "edit",
+  "link",
+  "unlink"
+]);
+function parseDoorstopRunOp(value) {
+  if (!DOORSTOP_RUN_OPS.has(value)) {
+    throw new Error(`Invalid doorstop run op: ${JSON.stringify(value)}`);
+  }
+  return value;
+}
+function requireStringArray(record, key) {
+  const values = requireArrayValue(record[key], key);
+  if (!values.every((entry) => typeof entry === "string")) {
+    throw new Error(`Expected string array field: ${key}`);
+  }
+  return values;
+}
+function optionalBoolean(record, key) {
+  const value = record[key];
+  if (value === void 0) return void 0;
+  if (typeof value !== "boolean") throw new Error(`Expected boolean field: ${key}`);
+  return value;
+}
+function requireUid(record, key) {
+  const value = requireString(record, key);
+  if (!isValidDoorstopUid(value)) {
+    throw new Error(`Invalid doorstop UID in field: ${key}`);
+  }
+  return value;
+}
+function requireItemPath(record, key) {
+  const value = requireString(record, key);
+  if (!isValidDoorstopItemPath(value)) {
+    throw new Error(`Invalid doorstop item path in field: ${key}`);
+  }
+  return value;
+}
+function parseDoorstopRunRequest(value) {
+  const record = requireRecord(value, "Doorstop run request");
+  const op = parseDoorstopRunOp(requireString(record, "op"));
+  switch (op) {
+    case "validate":
+      return { op };
+    case "publish": {
+      const target = requireString(record, "target");
+      if (!isValidPublishTarget(target)) {
+        throw new Error(
+          'Invalid publish target in doorstop.run request \u2014 must be a workspace-relative path (never absolute, never a drive-letter prefix, no ".." segment)'
+        );
+      }
+      return { op, target };
+    }
+    case "review": {
+      const uid = requireUid(record, "uid");
+      const commit = optionalBoolean(record, "commit");
+      return commit === void 0 ? { op, uid } : { op, uid, commit };
+    }
+    case "clear": {
+      const uid = requireUid(record, "uid");
+      const parents = requireStringArray(record, "parents");
+      if (parents.length === 0) {
+        throw new Error("Invalid doorstop.run clear request: at least one parent UID is required");
+      }
+      for (const parent of parents) {
+        if (!isValidDoorstopUid(parent)) throw new Error(`Invalid doorstop UID in field: parents`);
+      }
+      return { op, uid, parents };
+    }
+    case "edit":
+      return { op, uid: requireUid(record, "uid") };
+    case "link":
+    case "unlink": {
+      const uid = requireUid(record, "uid");
+      const target = requireUid(record, "target");
+      return { op, uid, target };
+    }
+  }
+}
+function parseDoorstopBaselineRequest(value) {
+  const record = requireRecord(value, "Doorstop baseline request");
+  return {
+    uid: requireUid(record, "uid"),
+    path: requireItemPath(record, "path")
+  };
+}
+var DOORSTOP_GIT_STATUS_OPERATION = "doorstop.git-status";
+var DOORSTOP_GIT_STATUS_FILES_MAX = 200;
+function parseDoorstopGitStatusRequest(value) {
+  requireRecord(value, "Doorstop git status request");
+  return {};
+}
+var DOORSTOP_GIT_STAGE_OPERATION = "doorstop.git-stage";
+function parseDoorstopGitStageRequest(value) {
+  const record = requireRecord(value, "Doorstop git stage request");
+  const paths = requireStringArray(record, "paths");
+  if (paths.length === 0) {
+    throw new Error("Invalid doorstop.git-stage request: at least one path is required");
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const uniquePaths = [];
+  for (const path of paths) {
+    if (!isValidDoorstopItemPath(path)) {
+      throw new Error(`Invalid doorstop item path in field: paths`);
+    }
+    if (!seen.has(path)) {
+      seen.add(path);
+      uniquePaths.push(path);
+    }
+  }
+  return { paths: uniquePaths };
+}
+var DOORSTOP_GIT_UNSTAGE_OPERATION = "doorstop.git-unstage";
+function parseDoorstopGitUnstageRequest(value) {
+  const record = requireRecord(value, "Doorstop git unstage request");
+  const paths = requireStringArray(record, "paths");
+  if (paths.length === 0) {
+    throw new Error("Invalid doorstop.git-unstage request: at least one path is required");
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const uniquePaths = [];
+  for (const path of paths) {
+    if (!isValidDoorstopItemPath(path)) {
+      throw new Error(`Invalid doorstop item path in field: paths`);
+    }
+    if (!seen.has(path)) {
+      seen.add(path);
+      uniquePaths.push(path);
+    }
+  }
+  return { paths: uniquePaths };
+}
+var DOORSTOP_GIT_COMMIT_OPERATION = "doorstop.git-commit";
+function isValidGitCommitMessage(value) {
+  if (value === "") return false;
+  if (value.length > 2e3) return false;
+  if (value.trim() === "") return false;
+  if (/[\u0000-\u001f\u007f-\u009f\u2028\u2029]/.test(value)) return false;
+  return true;
+}
+function parseDoorstopGitCommitRequest(value) {
+  const record = requireRecord(value, "Doorstop git commit request");
+  const message = requireString(record, "message");
+  if (!isValidGitCommitMessage(message)) {
+    throw new Error(
+      "Invalid git commit message \u2014 must be a non-blank single line of at most 2000 characters"
+    );
+  }
+  return { message: message.trim() };
+}
+
+// src/doorstop-backend.ts
+var DEFAULT_DOORSTOP_COMMAND = "doorstop";
+var DEFAULT_GIT_COMMAND = "git";
+var DEFAULT_DOORSTOP_TIMEOUT_MS = 8500;
+var DOORSTOP_UNSET_ENV_KEYS = Object.freeze(["DOORSTOP_HOME", "PYTHONPATH"]);
+var DOORSTOP_CLI_NOT_FOUND_MESSAGE = "opendoor: doorstop CLI not found on the sessiond host PATH \u2014 configure plugins.opendoor.settings.doorstopPath";
+var GIT_NOT_FOUND_MESSAGE = "opendoor: git not found on the sessiond host PATH \u2014 configure plugins.opendoor.settings.gitPath";
+var PIPELINE_DEADLINE_BUDGET_MS = 9500;
+var COMMIT_STDERR_EXCERPT_LIMIT = 2048;
+var GIT_UNSET_ENV_KEYS = Object.freeze([
+  "GIT_ALTERNATE_OBJECT_DIRECTORIES",
+  "GIT_COMMON_DIR",
+  "GIT_DIR",
+  "GIT_INDEX_FILE",
+  "GIT_OBJECT_DIRECTORY",
+  "GIT_PREFIX",
+  "GIT_QUARANTINE_PATH",
+  "GIT_WORK_TREE"
+]);
+var ITEM_PATH_WALK_MAX_DEPTH = 12;
+var ITEM_PATH_WALK_MAX_ENTRIES = 2048;
+var ITEM_PATH_WALK_SKIP_DIRS = /* @__PURE__ */ new Set([".git", "node_modules", ".pi-web"]);
+var activationRunQueues = /* @__PURE__ */ new WeakMap();
+async function requestDoorstopBackend(context, request) {
+  if (request.operation !== DOORSTOP_RUN_OPERATION) {
+    throw unsupportedBackendOperationError(request.operation);
+  }
+  const run = parseDoorstopRunRequest(request.input);
+  const settings = parseDoorstopBackendSettings(context.settings);
+  const cwd = request.workspace.path;
+  return runSerialized(context, cwd, async () => {
+    const startedAt = Date.now();
+    const result = await runDoorstop(
+      context,
+      settings,
+      cwd,
+      doorstopArgv(run),
+      request.signal,
+      Math.min(settings.timeoutMs, remainingBudgetMs(startedAt))
+    );
+    let commit;
+    if (run.op === "review" && run.commit === true) {
+      commit = result.exitCode === 0 ? await reviewCommitPipeline(context, settings, cwd, run.uid, request.signal, startedAt) : { status: "skipped" };
+    }
+    return doorstopRunResponse(run.op, result, Date.now() - startedAt, commit);
+  });
+}
+function doorstopArgv(run) {
+  switch (run.op) {
+    case "validate":
+      return [];
+    case "publish":
+      return ["publish", "all", run.target];
+    case "review":
+      return ["review", run.uid];
+    case "clear":
+      return ["clear", run.uid, ...run.parents];
+    case "edit":
+      return ["edit", run.uid];
+    case "link":
+      return ["link", run.uid, run.target];
+    case "unlink":
+      return ["unlink", run.uid, run.target];
+  }
+}
+async function runDoorstop(context, settings, cwd, args, signal, timeoutMs = settings.timeoutMs) {
+  try {
+    return await context.execFile({
+      file: settings.doorstopPath,
+      args,
+      cwd,
+      unsetEnv: DOORSTOP_UNSET_ENV_KEYS,
+      timeoutMs,
+      signal
+    });
+  } catch (error) {
+    if (isEnoentError(error)) {
+      throw new Error(DOORSTOP_CLI_NOT_FOUND_MESSAGE);
+    }
+    throw error;
+  }
+}
+function doorstopRunResponse(op, result, durationMs, commit) {
+  return {
+    op,
+    exitCode: result.exitCode,
+    signal: result.signal,
+    stdout: result.stdout,
+    stderr: result.stderr,
+    stdoutTruncated: result.stdoutTruncated,
+    stderrTruncated: result.stderrTruncated,
+    durationMs,
+    // Omitted unless the pipeline produced one (exactOptionalPropertyTypes:
+    // a response without `commit` must not carry the key at all). The spread
+    // yields a fresh object so the value admits the host bridge's JsonObject
+    // index signature (the interface itself lacks it).
+    ...commit === void 0 ? {} : { commit: { ...commit } }
+  };
+}
+async function runSerialized(context, cwd, action) {
+  let queues = activationRunQueues.get(context);
+  if (queues === void 0) {
+    queues = /* @__PURE__ */ new Map();
+    activationRunQueues.set(context, queues);
+  }
+  const previous = queues.get(cwd) ?? Promise.resolve();
+  const run = previous.then(action, action);
+  const tail = run.then(
+    () => void 0,
+    () => void 0
+  );
+  queues.set(cwd, tail);
+  try {
+    return await run;
+  } finally {
+    if (queues.get(cwd) === tail) queues.delete(cwd);
+  }
+}
+function parseDoorstopBackendSettings(settings) {
+  const configuredPath = settings["doorstopPath"];
+  const doorstopPath = typeof configuredPath === "string" && configuredPath !== "" ? configuredPath : DEFAULT_DOORSTOP_COMMAND;
+  const configuredGitPath = settings["gitPath"];
+  const gitPath = typeof configuredGitPath === "string" && configuredGitPath !== "" ? configuredGitPath : DEFAULT_GIT_COMMAND;
+  const configuredTimeout = settings["timeoutMs"];
+  const timeoutMs = typeof configuredTimeout === "number" && Number.isFinite(configuredTimeout) && configuredTimeout > 0 ? Math.min(configuredTimeout, DEFAULT_DOORSTOP_TIMEOUT_MS) : DEFAULT_DOORSTOP_TIMEOUT_MS;
+  return { doorstopPath, gitPath, timeoutMs };
+}
+function isEnoentError(error) {
+  return typeof error === "object" && error !== null && error.code === "ENOENT";
+}
+function unsupportedBackendOperationError(operation) {
+  return new Error(`opendoor: unsupported workspace backend operation: ${operation}`);
+}
+function remainingBudgetMs(startedAt) {
+  return PIPELINE_DEADLINE_BUDGET_MS - (Date.now() - startedAt);
+}
+function gitExecTimeoutMs(settings, startedAt) {
+  return Math.max(1, Math.min(settings.timeoutMs, remainingBudgetMs(startedAt)));
+}
+function commitStderrExcerpt(stderr) {
+  return stderr.length > COMMIT_STDERR_EXCERPT_LIMIT ? `${stderr.slice(0, COMMIT_STDERR_EXCERPT_LIMIT)}
+\u2026 (stderr truncated)` : stderr;
+}
+async function runGit(context, settings, cwd, args, signal, timeoutMs) {
+  try {
+    return await context.execFile({
+      file: settings.gitPath,
+      args,
+      cwd,
+      unsetEnv: GIT_UNSET_ENV_KEYS,
+      timeoutMs,
+      signal
+    });
+  } catch (error) {
+    if (isEnoentError(error)) {
+      throw new Error(GIT_NOT_FOUND_MESSAGE);
+    }
+    throw error;
+  }
+}
+function isWorkTreeResult(result) {
+  return result.exitCode === 0 && result.stdout.split(/\r?\n/, 1)[0] === "true";
+}
+function commitBracketSha(commitStdout) {
+  const firstLine = commitStdout.split(/\r?\n/, 1)[0] ?? "";
+  const match = /^\[.*\b([0-9a-f]{7,40})\](?:.*)$/.exec(firstLine);
+  return match?.[1];
+}
+function gitStepFailure(result, args) {
+  const stderr = result.stderr.trim();
+  const reason = stderr !== "" ? stderr : result.signal !== null ? `git ${args.join(" ")} ended from signal ${result.signal}` : `git ${args.join(" ")} exited ${String(result.exitCode)}`;
+  throw new Error(reason);
+}
+async function reviewCommitPipeline(context, settings, cwd, uid, signal, startedAt) {
+  try {
+    if (remainingBudgetMs(startedAt) <= 0) return { status: "skipped" };
+    const inWorkTree = await runGit(
+      context,
+      settings,
+      cwd,
+      ["rev-parse", "--is-inside-work-tree"],
+      signal,
+      gitExecTimeoutMs(settings, startedAt)
+    );
+    if (!isWorkTreeResult(inWorkTree)) return { status: "skipped" };
+    if (remainingBudgetMs(startedAt) <= 0) return { status: "skipped" };
+    const itemPath = await findItemPath(cwd, uid);
+    if (itemPath === void 0 || !isValidDoorstopItemPath(itemPath)) return { status: "skipped" };
+    if (remainingBudgetMs(startedAt) <= 0) return { status: "skipped" };
+    const status = await runGit(
+      context,
+      settings,
+      cwd,
+      ["status", "--porcelain", "--", literalPathspec(itemPath)],
+      signal,
+      gitExecTimeoutMs(settings, startedAt)
+    );
+    if (status.exitCode !== 0) gitStepFailure(status, ["status", "--porcelain", "--", literalPathspec(itemPath)]);
+    if (status.stdout === "") return { status: "clean" };
+    if (remainingBudgetMs(startedAt) <= 0) return { status: "skipped" };
+    const add = await runGit(context, settings, cwd, ["add", "--", literalPathspec(itemPath)], signal, gitExecTimeoutMs(settings, startedAt));
+    if (add.exitCode !== 0) gitStepFailure(add, ["add", "--", literalPathspec(itemPath)]);
+    if (remainingBudgetMs(startedAt) <= 0) return { status: "skipped" };
+    const commit = await runGit(
+      context,
+      settings,
+      cwd,
+      ["commit", "-m", `doorstop: review ${uid}`, "--", literalPathspec(itemPath)],
+      signal,
+      gitExecTimeoutMs(settings, startedAt)
+    );
+    if (commit.exitCode !== 0)
+      gitStepFailure(commit, ["commit", "-m", `doorstop: review ${uid}`, "--", literalPathspec(itemPath)]);
+    if (remainingBudgetMs(startedAt) <= 0) return { status: "skipped" };
+    const head = await runGit(
+      context,
+      settings,
+      cwd,
+      ["rev-parse", "--short", "HEAD"],
+      signal,
+      gitExecTimeoutMs(settings, startedAt)
+    );
+    if (head.exitCode !== 0) gitStepFailure(head, ["rev-parse", "--short", "HEAD"]);
+    const sha = head.stdout.trim();
+    if (sha === "") gitStepFailure(head, ["rev-parse", "--short", "HEAD"]);
+    return { status: "committed", sha };
+  } catch (error) {
+    if (signal.aborted) throw error;
+    return { status: "failed", stderr: commitStderrExcerpt(formatUnknownError(error)) };
+  }
+}
+async function requestDoorstopBaseline(context, request) {
+  if (request.operation !== DOORSTOP_BASELINE_OPERATION) {
+    throw unsupportedBackendOperationError(request.operation);
+  }
+  const baseline = parseDoorstopBaselineRequest(request.input);
+  const settings = parseDoorstopBackendSettings(context.settings);
+  const cwd = request.workspace.path;
+  return runSerialized(context, cwd, async () => {
+    const startedAt = Date.now();
+    const inWorkTree = await baselineGit(
+      context,
+      settings,
+      cwd,
+      ["rev-parse", "--is-inside-work-tree", "--show-prefix"],
+      request.signal,
+      startedAt
+    );
+    if (inWorkTree === void 0 || !isWorkTreeResult(inWorkTree)) {
+      return baselineResponse(false, "none", []);
+    }
+    const showPrefix = inWorkTree.stdout.split(/\r?\n/)[1] ?? "";
+    const pattern = `^doorstop: review ${escapeRegexMeta(baseline.uid)}$`;
+    const grep = await baselineGit(
+      context,
+      settings,
+      cwd,
+      [
+        "log",
+        `--max-count=${DOORSTOP_BASELINE_GREP_LIMIT}`,
+        `--grep=${pattern}`,
+        "--format=%H",
+        "--",
+        literalPathspec(baseline.path)
+      ],
+      request.signal,
+      startedAt
+    );
+    let shas;
+    let source;
+    if (grep !== void 0 && grep.exitCode === 0 && grep.stdout.trim() !== "") {
+      shas = grep.stdout.trim().split(/\r?\n/);
+      source = "review-commit";
+    } else {
+      const history = await baselineGit(
+        context,
+        settings,
+        cwd,
+        ["log", `--max-count=${DOORSTOP_BASELINE_HISTORY_LIMIT}`, "--format=%H", "--", literalPathspec(baseline.path)],
+        request.signal,
+        startedAt
+      );
+      if (history === void 0 || history.exitCode !== 0 || history.stdout.trim() === "") {
+        return baselineResponse(true, "none", []);
+      }
+      shas = history.stdout.trim().split(/\r?\n/);
+      source = "history";
+    }
+    const candidates = [];
+    for (const sha of shas) {
+      if (sha === "" || remainingBudgetMs(startedAt) <= 0) break;
+      const show = await baselineGit(
+        context,
+        settings,
+        cwd,
+        ["show", `${sha}:${showPrefix}${stripLeadingDotSlash(baseline.path)}`],
+        request.signal,
+        startedAt
+      );
+      if (show === void 0 || show.exitCode !== 0) continue;
+      if (show.stdout.length > DOORSTOP_BASELINE_BLOB_MAX) continue;
+      candidates.push({ sha, blob: show.stdout });
+    }
+    return baselineResponse(true, source, candidates);
+  });
+}
+async function baselineGit(context, settings, cwd, args, signal, startedAt) {
+  if (remainingBudgetMs(startedAt) <= 0) return void 0;
+  try {
+    return await runGit(context, settings, cwd, args, signal, gitExecTimeoutMs(settings, startedAt));
+  } catch {
+    return void 0;
+  }
+}
+function baselineResponse(git, source, candidates) {
+  return {
+    git,
+    source,
+    // Each candidate is spread into a fresh object so the value admits the
+    // host bridge's JsonObject index signature.
+    candidates: candidates.map((candidate) => ({ ...candidate }))
+  };
+}
+function escapeRegexMeta(value) {
+  return value.replace(/[.*\[\]^$\\]/g, "\\$&");
+}
+function literalPathspec(path) {
+  return `:(literal)${path}`;
+}
+function stripLeadingDotSlash(path) {
+  return path.replace(/^\.\//, "");
+}
+async function findItemPath(root, uid) {
+  let scanned = 0;
+  const walk = async (directory, depth, relPath) => {
+    if (scanned >= ITEM_PATH_WALK_MAX_ENTRIES || depth > ITEM_PATH_WALK_MAX_DEPTH) return void 0;
+    scanned += 1;
+    let entries;
+    try {
+      entries = await readdir(directory, { withFileTypes: true });
+    } catch {
+      return void 0;
+    }
+    for (const entry of entries) {
+      if (scanned >= ITEM_PATH_WALK_MAX_ENTRIES) return void 0;
+      scanned += 1;
+      if (entry.isDirectory()) {
+        if (!ITEM_PATH_WALK_SKIP_DIRS.has(entry.name)) {
+          const childRel = relPath === "" ? entry.name : `${relPath}/${entry.name}`;
+          const found = await walk(join(directory, entry.name), depth + 1, childRel);
+          if (found !== void 0) return found;
+        }
+      } else if (entry.isFile() && itemFileBase(entry.name) === uid) {
+        return relPath === "" ? entry.name : `${relPath}/${entry.name}`;
+      }
+    }
+    return void 0;
+  };
+  return walk(root, 0, "");
+}
+function itemFileBase(name) {
+  const dot = name.lastIndexOf(".");
+  if (dot <= 0) return void 0;
+  const extension = name.slice(dot).toLowerCase();
+  if (extension !== ".yml" && extension !== ".yaml" && extension !== ".md") return void 0;
+  return name.slice(0, dot);
+}
+async function requestDoorstopGitStatus(context, request) {
+  if (request.operation !== DOORSTOP_GIT_STATUS_OPERATION) {
+    throw unsupportedBackendOperationError(request.operation);
+  }
+  parseDoorstopGitStatusRequest(request.input);
+  const settings = parseDoorstopBackendSettings(context.settings);
+  const cwd = request.workspace.path;
+  return runSerialized(context, cwd, async () => {
+    const startedAt = Date.now();
+    const inWorkTree = await baselineGit(
+      context,
+      settings,
+      cwd,
+      ["rev-parse", "--is-inside-work-tree", "--show-prefix"],
+      request.signal,
+      startedAt
+    );
+    if (inWorkTree === void 0 || !isWorkTreeResult(inWorkTree)) {
+      return gitStatusResponse(false, void 0, void 0, void 0, 0, 0, []);
+    }
+    const porcelain = await baselineGit(
+      context,
+      settings,
+      cwd,
+      ["status", "--porcelain=v1", "-z", "-b"],
+      request.signal,
+      startedAt
+    );
+    if (porcelain === void 0 || porcelain.exitCode !== 0) {
+      return gitStatusResponse(false, void 0, void 0, void 0, 0, 0, []);
+    }
+    const parsed = parsePorcelainV1Status(porcelain.stdout);
+    return gitStatusResponse(
+      true,
+      parsed.branch,
+      parsed.ahead,
+      parsed.behind,
+      parsed.staged,
+      parsed.dirty,
+      parsed.files.slice(0, DOORSTOP_GIT_STATUS_FILES_MAX)
+    );
+  });
+}
+function gitStatusResponse(git, branch, ahead, behind, staged, dirty, files) {
+  return {
+    git,
+    ...branch === void 0 ? {} : { branch },
+    ...ahead === void 0 ? {} : { ahead },
+    ...behind === void 0 ? {} : { behind },
+    staged,
+    dirty,
+    // Each file is spread into a fresh object so the value admits the host
+    // bridge's JsonObject index signature.
+    files: files.map((file) => ({ ...file }))
+  };
+}
+function parsePorcelainV1Status(stdout) {
+  const output = stdout.split("\0");
+  const records = output[output.length - 1] === "" ? output.slice(0, -1) : output;
+  let branch;
+  let ahead;
+  let behind;
+  const files = [];
+  let staged = 0;
+  let dirty = 0;
+  for (let index = 0; index < records.length; index += 1) {
+    const record = records[index];
+    if (record === void 0) continue;
+    if (index === 0 && record.startsWith("## ")) {
+      const header = parsePorcelainBranchHeader(record.slice(3));
+      branch = header.branch;
+      ahead = header.ahead;
+      behind = header.behind;
+      continue;
+    }
+    const entry = /^(.{2}) (.*)$/s.exec(record);
+    if (entry === null) continue;
+    const xCode = entry[1]?.[0];
+    const yCode = entry[1]?.[1];
+    const indexState = gitFileStateFromPorcelainXy(xCode);
+    const workingTreeState = gitFileStateFromPorcelainXy(yCode);
+    files.push({ path: entry[2] ?? "", index: indexState, workingTree: workingTreeState });
+    if (indexState !== "unmodified" && indexState !== "untracked" && indexState !== "ignored") {
+      staged += 1;
+    }
+    if (indexState !== "unmodified" || workingTreeState !== "unmodified") {
+      dirty += 1;
+    }
+    if (xCode === "R" || xCode === "C") index += 1;
+  }
+  return {
+    ...branch === void 0 ? {} : { branch },
+    ...ahead === void 0 ? {} : { ahead },
+    ...behind === void 0 ? {} : { behind },
+    files,
+    staged,
+    dirty
+  };
+}
+function gitFileStateFromPorcelainXy(code) {
+  switch (code) {
+    case "M":
+    case "T":
+      return "modified";
+    case "A":
+      return "added";
+    case "D":
+      return "deleted";
+    case "R":
+      return "renamed";
+    case "C":
+      return "copied";
+    case "U":
+      return "conflicted";
+    case "?":
+      return "untracked";
+    case "!":
+      return "ignored";
+    default:
+      return "unmodified";
+  }
+}
+function parsePorcelainBranchHeader(header) {
+  let branchPart = header;
+  if (branchPart.startsWith("No commits yet on ")) {
+    branchPart = branchPart.slice("No commits yet on ".length);
+  }
+  if (branchPart === "HEAD (no branch)" || branchPart === "HEAD") return {};
+  const upstreamDot = branchPart.indexOf("...");
+  const branch = upstreamDot === -1 ? branchPart : branchPart.slice(0, upstreamDot);
+  let ahead;
+  let behind;
+  if (upstreamDot !== -1) {
+    const bracket = /^.*\[(.*)\]$/.exec(branchPart.slice(upstreamDot + 3));
+    if (bracket !== null && bracket[1] !== void 0) {
+      for (const part of bracket[1].split(",")) {
+        const aheadMatch = /^ahead (\d+)$/.exec(part.trim());
+        const behindMatch = /^behind (\d+)$/.exec(part.trim());
+        if (aheadMatch !== null) ahead = Number(aheadMatch[1]);
+        if (behindMatch !== null) behind = Number(behindMatch[1]);
+      }
+    }
+  }
+  return {
+    branch,
+    ...ahead === void 0 ? {} : { ahead },
+    ...behind === void 0 ? {} : { behind }
+  };
+}
+function stageAddTargets(stdout, paths) {
+  const output = stdout.split("\0");
+  const records = output[output.length - 1] === "" ? output.slice(0, -1) : output;
+  const requestSet = new Set(paths);
+  const targets = /* @__PURE__ */ new Set();
+  for (let index = 0; index < records.length; index += 1) {
+    const record = records[index];
+    if (record === void 0) continue;
+    const entry = /^(.{2}) (.*)$/s.exec(record);
+    if (entry === null) continue;
+    const xCode = entry[1]?.[0];
+    const yCode = entry[1]?.[1];
+    if (xCode === "R" || xCode === "C") index += 1;
+    if (yCode === void 0 || yCode === " ") continue;
+    const path = entry[2] ?? "";
+    if (requestSet.has(path)) targets.add(path);
+  }
+  return [...targets];
+}
+function unstageResetTargets(stdout, paths) {
+  const output = stdout.split("\0");
+  const records = output[output.length - 1] === "" ? output.slice(0, -1) : output;
+  const requestSet = new Set(paths);
+  const targets = /* @__PURE__ */ new Set();
+  for (let index = 0; index < records.length; index += 1) {
+    const record = records[index];
+    if (record === void 0) continue;
+    const entry = /^(.{2}) (.*)$/s.exec(record);
+    if (entry === null) continue;
+    const xCode = entry[1]?.[0];
+    const yCode = entry[1]?.[1];
+    if (xCode === "R" || xCode === "C") index += 1;
+    if (xCode === void 0 || xCode === " " || xCode === "?" || xCode === "!" || xCode === "U") continue;
+    if (yCode === "U" || (xCode === "A" || xCode === "D") && xCode === yCode) continue;
+    const path = entry[2] ?? "";
+    if (requestSet.has(path)) targets.add(path);
+  }
+  return [...targets];
+}
+async function requestDoorstopGitStage(context, request) {
+  if (request.operation !== DOORSTOP_GIT_STAGE_OPERATION) {
+    throw unsupportedBackendOperationError(request.operation);
+  }
+  const stage = parseDoorstopGitStageRequest(request.input);
+  const settings = parseDoorstopBackendSettings(context.settings);
+  const cwd = request.workspace.path;
+  return runSerialized(context, cwd, async () => {
+    const startedAt = Date.now();
+    try {
+      if (remainingBudgetMs(startedAt) <= 0) return stageResponse("skipped");
+      const inWorkTree = await runGit(
+        context,
+        settings,
+        cwd,
+        ["rev-parse", "--is-inside-work-tree"],
+        request.signal,
+        gitExecTimeoutMs(settings, startedAt)
+      );
+      if (!isWorkTreeResult(inWorkTree)) return stageResponse("skipped");
+      if (remainingBudgetMs(startedAt) <= 0) return stageResponse("skipped");
+      const pathspecs = stage.paths.map(literalPathspec);
+      const status = await runGit(
+        context,
+        settings,
+        cwd,
+        ["status", "--porcelain", "-z", "--", ...pathspecs],
+        request.signal,
+        gitExecTimeoutMs(settings, startedAt)
+      );
+      if (status.exitCode !== 0) {
+        gitStepFailure(status, ["status", "--porcelain", "-z", "--", ...pathspecs]);
+      }
+      const addPaths = stageAddTargets(status.stdout, stage.paths);
+      if (addPaths.length === 0) return stageResponse("clean");
+      if (remainingBudgetMs(startedAt) <= 0) return stageResponse("skipped");
+      const add = await runGit(
+        context,
+        settings,
+        cwd,
+        ["add", "--", ...addPaths.map(literalPathspec)],
+        request.signal,
+        gitExecTimeoutMs(settings, startedAt)
+      );
+      if (add.exitCode !== 0) gitStepFailure(add, ["add", "--", ...addPaths.map(literalPathspec)]);
+      return stageResponse("staged", addPaths.length);
+    } catch (error) {
+      if (request.signal.aborted) throw error;
+      return stageResponse("failed", void 0, commitStderrExcerpt(formatUnknownError(error)));
+    }
+  });
+}
+function stageResponse(status, staged, stderr) {
+  return {
+    status,
+    ...staged === void 0 ? {} : { staged },
+    ...stderr === void 0 ? {} : { stderr }
+  };
+}
+async function requestDoorstopGitUnstage(context, request) {
+  if (request.operation !== DOORSTOP_GIT_UNSTAGE_OPERATION) {
+    throw unsupportedBackendOperationError(request.operation);
+  }
+  const unstage = parseDoorstopGitUnstageRequest(request.input);
+  const settings = parseDoorstopBackendSettings(context.settings);
+  const cwd = request.workspace.path;
+  return runSerialized(context, cwd, async () => {
+    const startedAt = Date.now();
+    try {
+      if (remainingBudgetMs(startedAt) <= 0) return unstagedResponse("skipped");
+      const inWorkTree = await runGit(
+        context,
+        settings,
+        cwd,
+        ["rev-parse", "--is-inside-work-tree"],
+        request.signal,
+        gitExecTimeoutMs(settings, startedAt)
+      );
+      if (!isWorkTreeResult(inWorkTree)) return unstagedResponse("skipped");
+      if (remainingBudgetMs(startedAt) <= 0) return unstagedResponse("skipped");
+      const pathspecs = unstage.paths.map(literalPathspec);
+      const status = await runGit(
+        context,
+        settings,
+        cwd,
+        ["status", "--porcelain", "-z", "--", ...pathspecs],
+        request.signal,
+        gitExecTimeoutMs(settings, startedAt)
+      );
+      if (status.exitCode !== 0) {
+        gitStepFailure(status, ["status", "--porcelain", "-z", "--", ...pathspecs]);
+      }
+      const resetPaths = unstageResetTargets(status.stdout, unstage.paths);
+      if (resetPaths.length === 0) return unstagedResponse("clean");
+      if (remainingBudgetMs(startedAt) <= 0) return unstagedResponse("skipped");
+      const reset = await runGit(
+        context,
+        settings,
+        cwd,
+        ["reset", "-q", "--", ...resetPaths.map(literalPathspec)],
+        request.signal,
+        gitExecTimeoutMs(settings, startedAt)
+      );
+      if (reset.exitCode !== 0) gitStepFailure(reset, ["reset", "-q", "--", ...resetPaths.map(literalPathspec)]);
+      return unstagedResponse("unstaged", resetPaths.length);
+    } catch (error) {
+      if (request.signal.aborted) throw error;
+      return unstagedResponse("failed", void 0, commitStderrExcerpt(formatUnknownError(error)));
+    }
+  });
+}
+function unstagedResponse(status, unstaged, stderr) {
+  return {
+    status,
+    ...unstaged === void 0 ? {} : { unstaged },
+    ...stderr === void 0 ? {} : { stderr }
+  };
+}
+async function requestDoorstopGitCommit(context, request) {
+  if (request.operation !== DOORSTOP_GIT_COMMIT_OPERATION) {
+    throw unsupportedBackendOperationError(request.operation);
+  }
+  const commitRequest = parseDoorstopGitCommitRequest(request.input);
+  const settings = parseDoorstopBackendSettings(context.settings);
+  const cwd = request.workspace.path;
+  return runSerialized(context, cwd, async () => {
+    const startedAt = Date.now();
+    try {
+      if (remainingBudgetMs(startedAt) <= 0) return commitResponse({ status: "skipped" });
+      const inWorkTree = await runGit(
+        context,
+        settings,
+        cwd,
+        ["rev-parse", "--is-inside-work-tree"],
+        request.signal,
+        gitExecTimeoutMs(settings, startedAt)
+      );
+      if (!isWorkTreeResult(inWorkTree)) {
+        return commitResponse({ status: "skipped" });
+      }
+      if (remainingBudgetMs(startedAt) <= 0) return commitResponse({ status: "skipped" });
+      const staged = await runGit(
+        context,
+        settings,
+        cwd,
+        ["diff", "--cached", "--quiet"],
+        request.signal,
+        gitExecTimeoutMs(settings, startedAt)
+      );
+      if (staged.exitCode === 0) return commitResponse({ status: "clean" });
+      if (staged.exitCode !== 1) gitStepFailure(staged, ["diff", "--cached", "--quiet"]);
+      if (remainingBudgetMs(startedAt) <= 0) return commitResponse({ status: "skipped" });
+      const commit = await runGit(
+        context,
+        settings,
+        cwd,
+        ["commit", "-m", commitRequest.message],
+        request.signal,
+        gitExecTimeoutMs(settings, startedAt)
+      );
+      if (commit.exitCode !== 0) gitStepFailure(commit, ["commit", "-m", commitRequest.message]);
+      if (remainingBudgetMs(startedAt) <= 0) {
+        const fallback2 = commitBracketSha(commit.stdout);
+        return fallback2 === void 0 ? commitResponse({ status: "skipped" }) : commitResponse({ status: "committed", sha: fallback2 });
+      }
+      const head = await runGit(
+        context,
+        settings,
+        cwd,
+        ["rev-parse", "--short", "HEAD"],
+        request.signal,
+        gitExecTimeoutMs(settings, startedAt)
+      );
+      const fromHead = head.exitCode === 0 ? head.stdout.trim() : "";
+      if (fromHead !== "") return commitResponse({ status: "committed", sha: fromHead });
+      const fallback = commitBracketSha(commit.stdout);
+      if (fallback !== void 0) return commitResponse({ status: "committed", sha: fallback });
+      gitStepFailure(head, ["rev-parse", "--short", "HEAD"]);
+    } catch (error) {
+      if (request.signal.aborted) throw error;
+      return commitResponse({ status: "failed", stderr: commitStderrExcerpt(formatUnknownError(error)) });
+    }
+  });
+}
+function commitResponse(outcome) {
+  return { ...outcome };
+}
+
+// src/server-plugin.ts
+var DOORSTOP_MARKER_FILE = ".doorstop.yml";
+var PROBE_MAX_DEPTH = 3;
+var PROBE_MAX_ENTRIES = 256;
+var PROBE_SKIP_NAMES = /* @__PURE__ */ new Set([".git", "node_modules"]);
+async function probeContainsDoorstopMarker(root, signal) {
+  let scanned = 0;
+  const walk = async (directory, depth) => {
+    if (scanned >= PROBE_MAX_ENTRIES) return false;
+    scanned += 1;
+    let entries;
+    try {
+      if (signal.aborted) return false;
+      entries = await readdir2(directory, { withFileTypes: true });
+    } catch {
+      return false;
+    }
+    for (const entry of entries) {
+      if (scanned >= PROBE_MAX_ENTRIES) return false;
+      scanned += 1;
+      if (entry.isFile() && entry.name === DOORSTOP_MARKER_FILE) return true;
+      if (entry.isDirectory() && depth < PROBE_MAX_DEPTH && !PROBE_SKIP_NAMES.has(entry.name)) {
+        if (await walk(join2(directory, entry.name), depth + 1)) return true;
+      }
+    }
+    return false;
+  };
+  return walk(root, 0);
+}
+var plugin = {
+  apiVersion: 1,
+  name: "Opendoor",
+  activate(context) {
+    return { workspaceProvider: createDoorstopWorkspaceProvider(context) };
+  }
+};
+var server_plugin_default = plugin;
+function createDoorstopWorkspaceProvider(context) {
+  return Object.freeze({
+    async probe(project, signal) {
+      try {
+        if (await probeContainsDoorstopMarker(project.path, signal)) return "claim";
+        return "pass";
+      } catch {
+        return "pass";
+      }
+    },
+    async list(project, signal) {
+      return [
+        {
+          key: project.path,
+          path: project.path,
+          label: project.name,
+          isMain: true,
+          publicMetadata: { doorstop: true }
+        }
+      ];
+    },
+    request: (request) => {
+      switch (request.operation) {
+        case DOORSTOP_RUN_OPERATION:
+          return requestDoorstopBackend(context, request);
+        case DOORSTOP_BASELINE_OPERATION:
+          return requestDoorstopBaseline(context, request);
+        case DOORSTOP_GIT_STATUS_OPERATION:
+          return requestDoorstopGitStatus(context, request);
+        case DOORSTOP_GIT_STAGE_OPERATION:
+          return requestDoorstopGitStage(context, request);
+        case DOORSTOP_GIT_UNSTAGE_OPERATION:
+          return requestDoorstopGitUnstage(context, request);
+        case DOORSTOP_GIT_COMMIT_OPERATION:
+          return requestDoorstopGitCommit(context, request);
+        default:
+          return Promise.reject(unsupportedBackendOperationError(request.operation));
+      }
+    }
+  });
+}
+export {
+  createDoorstopWorkspaceProvider,
+  server_plugin_default as default
+};