fix(cli): report partial output only when present

sdk/typescript/src/cli.ts

@@ -10,13 +10,15 @@ import {
   constants,
   existsSync,
   lstatSync,
+  opendirSync,
   realpathSync,
   type BigIntStats,
   writeSync,
 } from "node:fs";
 import {
   lstat,
   mkdir,
+  opendir,
   open,
   readFile,
   realpath,
@@ -5051,6 +5053,46 @@ function isOutsidePath(path: string): boolean {
   return path === ".." || path.startsWith(`..${sep}`) || isAbsolute(path);
 }
 
+async function hasPartialOutput(path: string): Promise<boolean> {
+  let directory: Awaited<ReturnType<typeof opendir>> | undefined;
+  try {
+    directory = await opendir(path);
+    return (await directory.read()) !== null;
+  } catch (error: unknown) {
+    return !(
+      typeof error === "object" &&
+      error !== null &&
+      "code" in error &&
+      error.code === "ENOENT"
+    );
+  } finally {
+    if (directory !== undefined) {
+      try {
+        await directory.close();
+      } catch {}
+    }
+  }
+}
+
+function hasPartialOutputSync(path: string): boolean {
+  let directory: ReturnType<typeof opendirSync> | undefined;
+  try {
+    directory = opendirSync(path);
+    return directory.readSync() !== null;
+  } catch (error: unknown) {
+    return !(
+      typeof error === "object" &&
+      error !== null &&
+      "code" in error &&
+      error.code === "ENOENT"
+    );
+  } finally {
+    try {
+      directory?.closeSync();
+    } catch {}
+  }
+}
+
 async function runExport(
   arguments_: ExportArguments,
   output: Writable,
@@ -5769,41 +5811,49 @@ async function executeScan(
   }
 
   if (requestedSignal !== null) {
+    const partialOutput = scanDir !== null && hasPartialOutputSync(scanDir);
     diagnostic("scan.interrupted", {
       signal: requestedSignal,
-      partial_output: scanDir !== null,
+      partial_output: partialOutput,
     });
     return {
-      exitCode: interruptedExit(requestedSignal, scanDir, errorOutput),
+      exitCode: interruptedExit(
+        requestedSignal,
+        partialOutput ? scanDir : null,
+        errorOutput,
+      ),
       error:
         requestedSignal === "SIGINT"
           ? "Scan canceled by Ctrl-C."
           : "Scan terminated by SIGTERM.",
     };
   }
   if (failed) {
+    const partialOutput = scanDir !== null && (await hasPartialOutput(scanDir));
     const costLimitFailure =
       failure instanceof ScanCostLimitExceededError ? failure : undefined;
     const message =
       failure instanceof OutputInsideProtectedRootError
         ? errorMessage(protectedRootErrorMessage(failure))
-        : scanFailureMessage(failure, selectedAuthentication);
+        : costLimitFailure !== undefined
+          ? scanCostLimitFailureMessage(costLimitFailure, partialOutput)
+          : scanFailureMessage(failure, selectedAuthentication);
     diagnostic("scan.failed", {
       classification:
         costLimitFailure !== undefined
           ? "cost_limit_exceeded"
           : isLocalScanFailure(failure)
             ? "local"
             : classifyConnectionFailure(failure),
-      partial_output: scanDir !== null,
+      partial_output: partialOutput,
       max_cost_usd: costLimitFailure?.maxCostUsd,
       estimated_usd: costLimitFailure?.cost.estimatedUsd,
     });
     errorOutput.write(`${message}\n`);
     if (failure instanceof ScanInterruptedError) {
       return { exitCode: 2, error: message };
     }
-    if (scanDir !== null) {
+    if (partialOutput && scanDir !== null) {
       errorOutput.write(
         `Partial output was kept at ${errorMessage(scanDir)}.\n`,
       );
@@ -6097,6 +6147,16 @@ function scanFailureMessage(
   }
 }
 
+function scanCostLimitFailureMessage(
+  failure: ScanCostLimitExceededError,
+  partialOutput: boolean,
+): string {
+  const output = partialOutput
+    ? `partial output remains at ${errorMessage(failure.scanDir)}`
+    : "no partial output was kept";
+  return `Scan stopped: estimated cost ${formatUsd(failure.cost.estimatedUsd)} exceeded the ${formatUsd(failure.maxCostUsd)} limit; ${output}.`;
+}
+
 function scanScope(arguments_: ScanArguments): string | null {
   if (arguments_.paths.length > 0) {
     const displayed = arguments_.paths.slice(0, 3).map((path) => {