@superblocksteam/vite-plugin-file-sync 2.0.162-next.2 → 2.0.163-next.0

package/dist/ai-service/app-interface/shell.js

@@ -32,6 +32,7 @@ var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn,
     if (target) Object.defineProperty(target, contextIn.name, descriptor);
     done = true;
 };
+import { isUtf8 } from "node:buffer";
 import { exec, execFile } from "node:child_process";
 import { readFile as fsReadFile, mkdir, writeFile, access, rm, stat, readdir, } from "node:fs/promises";
 import * as path from "node:path";
@@ -58,6 +59,7 @@ import { DraftManager, validateFileOperation, } from "./filesystem/index.js";
 import { Linter } from "./linter.js";
 import { parseNpmJsonDiagnostic, parseNpmJsonError, parseNpmJsonSuccess, } from "./npm-error-parser.js";
 import { prepareForPrivateRegistry, shouldIgnoreInstallScripts, } from "./npm-registry.js";
+import { parseTypecheckOutputByPath } from "./typecheck-output-parser.js";
 import { applyPackageSubstitutions, runVulnerabilityGate, } from "./vulnerability-gate.js";
 const execPromise = promisify(exec);
 const execFilePromise = promisify(execFile);
@@ -345,7 +347,7 @@ let AppShell = (() => {
                             appShellQueueExecuteMs: executeMs,
                             appShellQueueOperation: operationName,
                             appShellQueueWaitMs: queueWaitMs,
-                            ...(metadata ?? {}),
+                            ...metadata,
                         },
                     });
                 }
@@ -377,19 +379,7 @@ let AppShell = (() => {
             });
         }
         async runTypecheck(abortSignal) {
-            const output = await this.runTypecheckRawOutput(abortSignal);
-            if (!output) {
-                return null;
-            }
-            const parsed = output.split("\n").reduce((acc, line) => {
-                const [filePath, _rest] = line.split("(");
-                if (filePath && filePath.trim() !== "") {
-                    acc[filePath] = [...(acc[filePath] || []), line];
-                    return acc;
-                }
-                return acc;
-            }, {});
-            return Object.keys(parsed).length > 0 ? parsed : null;
+            return parseTypecheckOutputByPath(await this.runTypecheckRawOutput(abortSignal));
         }
         async runTypecheckRawOutput(abortSignal) {
             const command = process.env.SUPERBLOCKS_SERVER_ENV === "local"
@@ -787,7 +777,7 @@ let AppShell = (() => {
                 // Audit reporting is best-effort and must not affect the install.
             }
         }
-        maybeReportBlockedInstall(err, runner) {
+        maybeReportBlockedInstall(err, runner, triageVerdicts) {
             if (!(err instanceof NpmInstallBlocked))
                 return;
             // Audit only real CVE/malware findings — index/probe failures are fail-closed
@@ -817,17 +807,12 @@ let AppShell = (() => {
                 npmErrorCode: err.npmErrorCode,
                 runner,
                 occurredAt: Date.now(),
+                ...(triageVerdicts?.length ? { triageVerdicts } : {}),
                 ...(vulnerabilities?.length ? { vulnerabilities } : {}),
             });
         }
-        reportNpmTriageVerdict(verdict) {
-            this.safeAudit({
-                occurredAt: Date.now(),
-                packages: [verdict.package],
-                reason: "vulnerability_triaged",
-                runner: "install_specific",
-                triage: verdict,
-            });
+        reportNpmBlockedInstall(error, triageVerdicts) {
+            this.maybeReportBlockedInstall(error, "install_specific", triageVerdicts);
         }
         reportNpmUserOverride(args) {
             this.safeAudit({
@@ -836,6 +821,7 @@ let AppShell = (() => {
                 reason: "vulnerability_user_override",
                 runner: "install_specific",
                 userOverride: {
+                    ...(args.advisories?.length ? { advisories: args.advisories } : {}),
                     packages: args.packages,
                     reason: args.reason,
                 },
@@ -1742,6 +1728,7 @@ let AppShell = (() => {
                     if (options?.cveUserOverride &&
                         remediation.userOverridePackages?.length) {
                         this.reportNpmUserOverride({
+                            advisories: remediation.userOverrideAdvisories,
                             packages: remediation.userOverridePackages,
                             reason: options.cveUserOverride.reason,
                         });
@@ -1751,7 +1738,9 @@ let AppShell = (() => {
             }
             catch (err) {
                 outcome = outcomeFromInstallError(err);
-                this.maybeReportBlockedInstall(err, "install_specific");
+                if (!options?.deferBlockedAudit) {
+                    this.maybeReportBlockedInstall(err, "install_specific");
+                }
                 throw err;
             }
             finally {
@@ -1931,9 +1920,6 @@ let AppShell = (() => {
                 }
             });
         }
-        // ============================================================================
-        // Filesystem Operations
-        // ============================================================================
         /**
          * Reads a single file's content from the application.
          *
@@ -2041,6 +2027,40 @@ let AppShell = (() => {
          * Called directly by writeFile (no queue wrapper needed since draftInterface queues).
          */
         async writeFileInternal(relativePath, rawContent) {
+            const content = this.prepareFileContent(relativePath, rawContent);
+            if (this.virtualFs.isVirtualPath(relativePath)) {
+                if (typeof content !== "string") {
+                    throw new Error(`Cannot write binary content to virtual file: ${relativePath}`);
+                }
+                await this.virtualFs.write(relativePath, content, {
+                    appRootDirPath: this.appRootDirPath,
+                });
+                await this.draftManager.createDraftMarker(relativePath);
+                return;
+            }
+            const change = this.preparePhysicalWrite(relativePath, content);
+            await this.draftManager.applyDraftChanges([change]);
+        }
+        /**
+         * Reject a write of TypeScript that does not parse, before it reaches disk.
+         * A file that does not parse blanks the preview, and nothing downstream can
+         * read what it imports.
+         */
+        rejectUnparseableTypeScript(relativePath, content) {
+            if (!relativePath.endsWith(".ts") && !relativePath.endsWith(".tsx")) {
+                return;
+            }
+            try {
+                parseTsxModule(typeof content === "string" ? content : content.toString("utf8"), relativePath);
+            }
+            catch (error) {
+                getLogger().warn(`TSX parse validation rejected write: ${relativePath}`, getErrorMeta(error));
+                emitWriteTsxParseRejectedMetric(relativePath.endsWith(".tsx") ? "tsx" : "ts");
+                const message = error instanceof Error ? error.message : String(error);
+                throw new ToolExecutionError(`${relativePath}: ${message}`);
+            }
+        }
+        prepareFileContent(relativePath, rawContent) {
             // Deterministic safety net: rewrite value imports of `lucide-react/dynamic`
             // type-only exports (e.g. `IconName`) into type imports. A stray value
             // import compiles but crashes the app at runtime and blanks the preview,
@@ -2061,34 +2081,12 @@ let AppShell = (() => {
                     }
                 }
             }
-            const isVirtual = this.virtualFs.isVirtualPath(relativePath);
-            if (Buffer.isBuffer(content) && isVirtual) {
-                throw new Error(`Cannot write binary content to virtual file: ${relativePath}`);
-            }
-            if (!isVirtual) {
-                validateFileOperation("write", relativePath, this.appRootDirPath, undefined, this.pathValidator, this.getFileOperationBlacklistOptions());
-                if (relativePath.endsWith(".ts") || relativePath.endsWith(".tsx")) {
-                    try {
-                        parseTsxModule(typeof content === "string" ? content : content.toString("utf8"), relativePath);
-                    }
-                    catch (error) {
-                        getLogger().warn(`TSX parse validation rejected write: ${relativePath}`, getErrorMeta(error));
-                        emitWriteTsxParseRejectedMetric(relativePath.endsWith(".tsx") ? "tsx" : "ts");
-                        const message = error instanceof Error ? error.message : String(error);
-                        throw new ToolExecutionError(`${relativePath}: ${message}`);
-                    }
-                }
-            }
-            if (isVirtual) {
-                await this.virtualFs.write(relativePath, content, {
-                    appRootDirPath: this.appRootDirPath,
-                });
-                await this.draftManager.createDraftMarker(relativePath);
-                return;
-            }
-            const absolutePath = path.join(this.appRootDirPath, relativePath);
-            await mkdir(path.dirname(absolutePath), { recursive: true });
-            await this.draftManager.createDraft(relativePath, content);
+            return content;
+        }
+        preparePhysicalWrite(relativePath, content) {
+            validateFileOperation("write", relativePath, this.appRootDirPath, undefined, this.pathValidator, this.getFileOperationBlacklistOptions());
+            this.rejectUnparseableTypeScript(relativePath, content);
+            return { filePath: relativePath, content };
         }
         resolveAppRelativePath(relativePath, direction) {
             if (path.isAbsolute(relativePath)) {
@@ -2239,26 +2237,34 @@ let AppShell = (() => {
                 result,
                 sourceDir: options.sourceDir,
             });
+            const hasVirtualDestination = entries.some((entry) => this.virtualFs.isVirtualPath(entry.destinationPath));
+            const hasPhysicalDestination = entries.some((entry) => !this.virtualFs.isVirtualPath(entry.destinationPath));
+            if (hasVirtualDestination && hasPhysicalDestination) {
+                throw new Error("Cannot copy a directory to mixed physical and virtual files. Copy the physical and virtual files separately.");
+            }
             if ((options.conflictStrategy ?? "fail") === "fail") {
                 for (const entry of entries) {
                     await this.preflightCopyFile(entry);
                 }
             }
+            const physicalChanges = [];
             for (const entry of entries) {
-                await this.copyFileInternal({
-                    // The "fail" strategy is preflighted above so we avoid copying part of
-                    // a directory before discovering an existing destination. This is not
-                    // fully atomic: a destination could still appear between preflight and
-                    // write. Closing that race properly needs a reentrant fs-operation lock
-                    // so the whole directory copy can hold the lock while nested draft
-                    // writes reuse the parent lock instead of deadlocking.
-                    conflictStrategy: (options.conflictStrategy ?? "fail") === "fail"
-                        ? "replace"
-                        : options.conflictStrategy,
-                    destinationPath: entry.destinationPath,
-                    result,
-                    sourcePath: entry.sourcePath,
-                });
+                const destinationExists = await this.pathExists(entry.destinationPath);
+                if (destinationExists && options.conflictStrategy === "skip") {
+                    this.recordSkipped(result, entry.destinationPath, "destination_exists");
+                    continue;
+                }
+                const content = await fsReadFile(this.resolveAppRelativePath(entry.sourcePath, "from"));
+                if (this.virtualFs.isVirtualPath(entry.destinationPath)) {
+                    await this.writeFileInternal(entry.destinationPath, isUtf8(content) ? content.toString("utf-8") : content);
+                }
+                else {
+                    physicalChanges.push(this.preparePhysicalWrite(entry.destinationPath, this.prepareFileContent(entry.destinationPath, content)));
+                }
+                this.recordCopied(result, entry.destinationPath);
+            }
+            if (physicalChanges.length > 0) {
+                await this.draftManager.applyDraftChanges(physicalChanges);
             }
             llmobs.annotate({
                 metadata: {
@@ -2302,23 +2308,13 @@ let AppShell = (() => {
             validateFileOperation("delete", relativePath, this.appRootDirPath, undefined, this.pathValidator, this.getFileOperationBlacklistOptions());
             const absolutePath = path.join(this.appRootDirPath, relativePath);
             // Check if path exists and what type it is
-            let stats;
             try {
-                stats = await stat(absolutePath);
+                await stat(absolutePath);
             }
             catch {
                 throw new Error(`File or directory ${relativePath} not found`);
             }
-            if (stats.isDirectory()) {
-                // Recursively delete directory contents
-                await this.deleteDirectoryRecursive(absolutePath);
-                // Remove the directory itself
-                await rm(absolutePath, { recursive: true, force: true });
-            }
-            else {
-                // Single file deletion
-                await this.draftManager.createDraftDelete(relativePath);
-            }
+            await this.draftManager.createDraftDelete(relativePath);
         }
         /**
          * Implementation of listFiles supporting both signatures.
@@ -2490,14 +2486,23 @@ let AppShell = (() => {
             if (this.isReadRequired(oldPath)) {
                 throw new Error(`Cannot rename ${oldPath} without reading it first. Please read the file before attempting to rename it.`);
             }
-            // Read content first (this is just fs read, no queue needed)
+            const oldIsVirtual = this.virtualFs.isVirtualPath(oldPath);
+            const newIsVirtual = this.virtualFs.isVirtualPath(newPath);
+            if (oldIsVirtual !== newIsVirtual) {
+                throw new Error("Cannot rename between physical and virtual files. Copy the file and delete the source separately.");
+            }
             const content = await this.readFileInternal(oldPath);
-            await this.writeFileInternal(newPath, content);
-            await this.deleteFileInternal(oldPath);
+            if (!oldIsVirtual && !newIsVirtual) {
+                await this.draftManager.applyDraftChanges([
+                    this.preparePhysicalWrite(newPath, this.prepareFileContent(newPath, content)),
+                    { filePath: oldPath },
+                ]);
+            }
+            else {
+                await this.writeFileInternal(newPath, content);
+                await this.deleteFileInternal(oldPath);
+            }
         }
-        // ============================================================================
-        // Draft Management
-        // ============================================================================
         /**
          * Checks if there are any pending draft changes.
          *
@@ -2544,9 +2549,6 @@ let AppShell = (() => {
         getDraftInterface() {
             return this.draftManager?.getInterface();
         }
-        // ============================================================================
-        // Read Tracking (Read-Before-Write Enforcement)
-        // ============================================================================
         /**
          * Check if a file must be read before it can be written.
          *
@@ -2579,28 +2581,6 @@ let AppShell = (() => {
                 useLessProtectedPatterns: this.enableDeletingLockfiles,
             };
         }
-        // ============================================================================
-        // Private Helpers
-        // ============================================================================
-        /**
-         * Recursively deletes directory contents by creating draft deletes.
-         */
-        async deleteDirectoryRecursive(dirPath) {
-            if (!this.draftManager) {
-                throw new Error("DraftInterface is required for directory deletion");
-            }
-            const entries = await readdir(dirPath, { withFileTypes: true });
-            for (const entry of entries) {
-                const fullPath = path.join(dirPath, entry.name);
-                const relativePath = path.relative(this.appRootDirPath, fullPath);
-                if (entry.isDirectory()) {
-                    await this.deleteDirectoryRecursive(fullPath);
-                }
-                else {
-                    await this.draftManager.createDraftDelete(relativePath);
-                }
-            }
-        }
     };
 })();
 export { AppShell };