@spotpatch/vite 1.2.1 → 1.3.0

package/README.md

@@ -62,5 +62,12 @@ spotPatch({
 The full provider map remains available for multiple providers, multiple models,
 custom labels, checks, and limits.
 
+AI runs directly when the Git workspace is clean. If staged, unstaged, or
+bounded regular untracked files exist, the workbench reports their counts and
+requires explicit consent before copying them into an isolated Agent baseline.
+SpotPatch never stashes, resets, commits, or changes the source index, and Apply
+or Revert touches only the Agent delta. Conflicts and unsupported workspace
+states remain blocked with an actionable reason.
+
 See the [repository README](https://github.com/huanglvjing/spotpatch#readme) for
 the complete setup and security model.

package/dist/index.cjs

@@ -515,7 +515,7 @@ var import_node_path2 = __toESM(require("path"), 1);
 // package.json
 var package_default = {
   name: "@spotpatch/vite",
-  version: "1.2.1",
+  version: "1.3.0",
   description: "Vite development plugin for SpotPatch.",
   license: "MIT",
   repository: {
@@ -709,6 +709,7 @@ var DEFAULT_DEPENDENCIES = Object.freeze({
   applyChange: import_agent.applyPreparedAgentChange,
   createJobId: () => (0, import_node_crypto2.randomBytes)(16).toString("base64url"),
   executeChange: import_agent.executeAgentChange,
+  inspectWorkspace: import_agent.inspectAgentWorkspace,
   now: () => (/* @__PURE__ */ new Date()).toISOString(),
   probeCapability: import_agent.probeProviderCapability,
   resolveCredential: import_agent.resolveProviderCredential,
@@ -928,6 +929,7 @@ function createAgentJobManager(options) {
         provider: job.provider,
         root: options.root,
         signal: job.controller.signal,
+        workingTreeMode: job.workingTreeMode,
         ...options.fetch === void 0 ? {} : { fetch: options.fetch }
       });
       job.preparedChange = preparedChange;
@@ -1064,7 +1066,8 @@ function createAgentJobManager(options) {
         runPromise: void 0,
         sequence: 0,
         status: "queued",
-        updatedAt: timestamp
+        updatedAt: timestamp,
+        workingTreeMode: request.workingTreeMode
       };
       jobs.set(id, job);
       emitSnapshot(job);
@@ -1119,6 +1122,12 @@ function createAgentJobManager(options) {
       return () => {
         job.listeners.delete(listener);
       };
+    },
+    workspaceHealth(signal) {
+      if (closed) {
+        throw new import_shared2.SpotPatchError(import_shared2.ERROR_CODES.AI_DISABLED);
+      }
+      return dependencies.inspectWorkspace(options.root, signal);
     }
   });
 }
@@ -1603,7 +1612,8 @@ async function authorizeAgentJobRequest(input) {
     annotation,
     providerProfileId: input.request.providerProfileId,
     modelProfileId: input.request.modelProfileId,
-    providerDataConsent: true
+    providerDataConsent: true,
+    workingTreeMode: input.request.workingTreeMode
   });
 }
 
@@ -1669,6 +1679,9 @@ function matchAgentRequestPath(path11) {
   if (path11 === import_shared7.SPOTPATCH_ENDPOINTS.agentCapability) {
     return Object.freeze({ kind: "capability" });
   }
+  if (path11 === import_shared7.SPOTPATCH_ENDPOINTS.agentWorkspaceHealth) {
+    return Object.freeze({ kind: "workspace-health" });
+  }
   if (path11 === import_shared7.SPOTPATCH_ENDPOINTS.agentJobs) {
     return Object.freeze({ kind: "create-job" });
   }
@@ -1785,6 +1798,28 @@ async function handleCreateJob(request, response, options, writeSuccess) {
   const data = requireAgentManager(options).create(authorizedRequest);
   writeSuccess(response, 202, data);
 }
+async function handleWorkspaceHealth(request, response, options, writeSuccess) {
+  if (request.method !== "POST") {
+    throw new import_shared7.SpotPatchError(import_shared7.ERROR_CODES.INVALID_REQUEST);
+  }
+  const parsed = import_shared7.agentWorkspaceHealthRequestSchema.safeParse(
+    await readJsonRequestBody(request)
+  );
+  if (!parsed.success) {
+    throw new import_shared7.SpotPatchError(import_shared7.ERROR_CODES.INVALID_REQUEST);
+  }
+  const controller = new AbortController();
+  const abort = () => {
+    controller.abort("agent-workspace-health-client-disconnected");
+  };
+  response.once("close", abort);
+  try {
+    const data = await requireAgentManager(options).workspaceHealth(controller.signal);
+    writeSuccess(response, 200, data);
+  } finally {
+    response.removeListener("close", abort);
+  }
+}
 async function handleJobAction(request, response, options, route, writeSuccess) {
   const manager = requireAgentManager(options);
   if (request.method !== "POST") {
@@ -1816,41 +1851,97 @@ async function handleAgentRequest(request, response, options, route, writeSucces
     await handleCreateJob(request, response, options, writeSuccess);
     return;
   }
+  if (route.kind === "workspace-health") {
+    await handleWorkspaceHealth(request, response, options, writeSuccess);
+    return;
+  }
   await handleJobAction(request, response, options, route, writeSuccess);
 }
 
 // src/server/editor.ts
+var import_node_child_process = require("child_process");
 var import_launch_editor = __toESM(require("launch-editor"), 1);
-var EDITOR_STARTUP_GRACE_MS = 150;
-function editorCommand(editor) {
-  if (editor === "vscode") {
-    return "code";
-  }
-  if (editor === "cursor") {
+var EDITOR_STARTUP_GRACE_MS = 300;
+function normalizedEditorEnvironment(environment) {
+  return [
+    environment.TERM_PROGRAM,
+    environment.VSCODE_GIT_ASKPASS_NODE,
+    environment.VSCODE_GIT_ASKPASS_MAIN,
+    environment.GIT_ASKPASS
+  ].filter((value) => typeof value === "string").join("\n").replaceAll("\\", "/").toLowerCase();
+}
+function detectIntegratedEditor(environment) {
+  const signature = normalizedEditorEnvironment(environment);
+  if (signature === "cursor" || signature.includes("/cursor")) {
     return "cursor";
   }
+  if (signature === "vscode" || signature.includes("visual studio code") || /(^|\/)(code|code-insiders)(\.exe)?($|\/)/u.test(signature)) {
+    return "vscode";
+  }
   return void 0;
 }
-var launchConfiguredEditor = (target, editor) => new Promise((resolve, reject) => {
-  let settled = false;
-  const startupTimer = setTimeout(() => {
-    settled = true;
-    resolve();
-  }, EDITOR_STARTUP_GRACE_MS);
-  const rejectStartup = () => {
-    if (settled) {
-      return;
-    }
-    settled = true;
-    clearTimeout(startupTimer);
-    reject(new Error("The configured editor could not be started."));
-  };
-  try {
-    (0, import_launch_editor.default)(target, editorCommand(editor), rejectStartup);
-  } catch {
-    rejectStartup();
-  }
+function editorCommand(editor) {
+  return editor === "cursor" ? "cursor" : "code";
+}
+var DEFAULT_DEPENDENCIES2 = Object.freeze({
+  environment: process.env,
+  fallbackLauncher: import_launch_editor.default,
+  processSpawner: (command, arguments_, options) => (0, import_node_child_process.spawn)(command, [...arguments_], options),
+  startupGraceMs: EDITOR_STARTUP_GRACE_MS
 });
+function createEditorLauncher(dependencies = DEFAULT_DEPENDENCIES2) {
+  return (target, configuredEditor) => {
+    const integratedEditor = detectIntegratedEditor(dependencies.environment);
+    const resolvedEditor = configuredEditor === "auto" ? integratedEditor : configuredEditor;
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      const settle = (error, editor = resolvedEditor ?? "auto") => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        clearTimeout(startupTimer);
+        if (error === void 0) {
+          resolve(editor);
+        } else {
+          reject(error);
+        }
+      };
+      const startupTimer = setTimeout(settle, dependencies.startupGraceMs);
+      const rejectStartup = () => {
+        settle(new Error("The configured editor could not be started."));
+      };
+      try {
+        if (resolvedEditor === void 0) {
+          dependencies.fallbackLauncher(target, void 0, rejectStartup);
+          return;
+        }
+        const child = dependencies.processSpawner(
+          editorCommand(resolvedEditor),
+          ["--goto", target],
+          {
+            env: dependencies.environment,
+            stdio: "ignore",
+            windowsHide: true
+          }
+        );
+        child.once("error", rejectStartup);
+        child.once("exit", (code, signal) => {
+          if (code === 0) {
+            settle(void 0, resolvedEditor);
+            return;
+          }
+          if (code !== null || signal !== null) {
+            rejectStartup();
+          }
+        });
+      } catch {
+        rejectStartup();
+      }
+    });
+  };
+}
+var launchConfiguredEditor = createEditorLauncher();
 
 // src/server/request-security.ts
 var import_node_crypto3 = require("crypto");
@@ -1944,7 +2035,15 @@ var STATUS_BY_ERROR = Object.freeze({
   [import_shared9.ERROR_CODES.AGENT_LIMIT_EXCEEDED]: 413,
   [import_shared9.ERROR_CODES.AGENT_CANCELLED]: 409,
   [import_shared9.ERROR_CODES.WORKTREE_DIRTY]: 409,
+  [import_shared9.ERROR_CODES.WORKTREE_NOT_REPOSITORY]: 409,
+  [import_shared9.ERROR_CODES.WORKTREE_OPERATION_IN_PROGRESS]: 409,
+  [import_shared9.ERROR_CODES.WORKTREE_CONFLICTED]: 409,
+  [import_shared9.ERROR_CODES.WORKTREE_LOCAL_CHANGES_TOO_LARGE]: 413,
+  [import_shared9.ERROR_CODES.WORKTREE_UNTRACKED_UNSUPPORTED]: 409,
+  [import_shared9.ERROR_CODES.WORKTREE_LOCAL_CHANGES_UNSUPPORTED]: 409,
   [import_shared9.ERROR_CODES.TOOL_DENIED]: 403,
+  [import_shared9.ERROR_CODES.TOOL_INPUT_INVALID]: 422,
+  [import_shared9.ERROR_CODES.TOOL_PATH_DENIED]: 403,
   [import_shared9.ERROR_CODES.PATCH_REJECTED]: 422,
   [import_shared9.ERROR_CODES.VALIDATION_FAILED]: 422,
   [import_shared9.ERROR_CODES.APPLY_CONFLICT]: 409,
@@ -1968,8 +2067,16 @@ var PUBLIC_MESSAGES = Object.freeze({
   [import_shared9.ERROR_CODES.AGENT_BUSY]: "Another Agent job is already running.",
   [import_shared9.ERROR_CODES.AGENT_LIMIT_EXCEEDED]: "The Agent job exceeded a safety limit.",
   [import_shared9.ERROR_CODES.AGENT_CANCELLED]: "The Agent job was cancelled.",
-  [import_shared9.ERROR_CODES.WORKTREE_DIRTY]: "The project worktree must be clean.",
+  [import_shared9.ERROR_CODES.WORKTREE_DIRTY]: "Local changes require explicit inclusion consent.",
+  [import_shared9.ERROR_CODES.WORKTREE_NOT_REPOSITORY]: "The project root is not a Git repository.",
+  [import_shared9.ERROR_CODES.WORKTREE_OPERATION_IN_PROGRESS]: "A Git operation is currently in progress.",
+  [import_shared9.ERROR_CODES.WORKTREE_CONFLICTED]: "The local workspace contains unresolved merge conflicts.",
+  [import_shared9.ERROR_CODES.WORKTREE_LOCAL_CHANGES_TOO_LARGE]: "The local workspace exceeds the safe isolation size limit.",
+  [import_shared9.ERROR_CODES.WORKTREE_UNTRACKED_UNSUPPORTED]: "An untracked path cannot be isolated safely.",
+  [import_shared9.ERROR_CODES.WORKTREE_LOCAL_CHANGES_UNSUPPORTED]: "The local workspace state cannot be isolated safely.",
   [import_shared9.ERROR_CODES.TOOL_DENIED]: "The Agent tool request was denied.",
+  [import_shared9.ERROR_CODES.TOOL_INPUT_INVALID]: "The Agent tool input was invalid.",
+  [import_shared9.ERROR_CODES.TOOL_PATH_DENIED]: "The Agent tool path was denied.",
   [import_shared9.ERROR_CODES.PATCH_REJECTED]: "The proposed patch was rejected.",
   [import_shared9.ERROR_CODES.VALIDATION_FAILED]: "The proposed change failed validation.",
   [import_shared9.ERROR_CODES.APPLY_CONFLICT]: "The change conflicts with the current worktree.",
@@ -2033,7 +2140,8 @@ async function handleOpenEditor(request, options) {
   const target = `${sourcePath}:${String(body.line)}:${String(body.column)}`;
   const editorLauncher = options.editorLauncher ?? launchConfiguredEditor;
   try {
-    await editorLauncher(target, options.options.editor);
+    const editor = await editorLauncher(target, options.options.editor);
+    return Object.freeze({ editor });
   } catch (error) {
     options.logger?.warn(
       `[spotpatch:server] ${options.options.editor === "auto" ? "The detected editor" : options.options.editor} rejected an editor request.`
@@ -2042,7 +2150,6 @@ async function handleOpenEditor(request, options) {
       cause: error
     });
   }
-  return Object.freeze({ editor: options.options.editor });
 }
 function createSpotPatchMiddleware(options) {
   return (request, response, next) => {