@tapi-dev/sdk 0.1.28 → 0.1.30

package/dist/cli.d.ts

@@ -114,10 +114,9 @@ export declare function validateStudioManifest(input: unknown): StudioReleaseMan
 export declare function validateServiceReleaseManifest(input: unknown): ServiceReleaseManifest;
 export declare function compareVersions(left: string, right: string): number;
 export declare function memoizeStudioInstallToken(options: StudioCliOptions, installToken?: string): string;
-export declare function tryOpenExistingPortableStudioServer(options: StudioCliOptions, manifest: StudioReleaseManifest, fetchImpl?: FetchLike, openBrowserImpl?: (url: string) => void): Promise<{
-    opened: boolean;
-    baseUrl?: string;
-    reason?: string;
+export declare function closeExistingPortableStudioServersForFreshLaunch(stopProcesses?: () => Promise<number>): Promise<{
+    stopped: number;
+    recordsRemoved: number;
 }>;
 export declare function findPortablePlaywrightBrowsersDir(exePath: string): string | undefined;
 export declare function waitForHttpOk(url: string, timeoutMs?: number, intervalMs?: number, fetchImpl?: FetchLike): Promise<void>;
@@ -126,7 +125,9 @@ export declare function chooseStudioPort(preferred?: number, options?: {
     portAvailable?: StudioPortAvailable;
     reapBlockedPorts?: StudioPortReaper;
 }): Promise<number>;
-export declare function downloadAndVerify(url: string, destination: string, expectedSha256: string, label?: string): Promise<void>;
+export declare function downloadAndVerify(url: string, destination: string, expectedSha256: string, label?: string, options?: {
+    stallTimeoutMs?: number;
+}): Promise<void>;
 export declare function studioInstanceRecordPathForOptions(options: StudioCliOptions): string;
 export declare function findPortableStudioServerExe(releaseDir: string, manifest: StudioReleaseManifest): string | undefined;
 export declare function estimateRequiredExtractionBytes(zipBytes: number): number;

package/dist/cli.js

@@ -9,7 +9,7 @@ import { homedir } from "node:os";
 import { basename, dirname, join, resolve } from "node:path";
 import { performance } from "node:perf_hooks";
 import { emitKeypressEvents } from "node:readline";
-import { Readable } from "node:stream";
+import { Readable, Transform } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { TapiClient } from "./index.js";
@@ -23,6 +23,8 @@ const SUPPORTED_STUDIO_PLATFORM = "windows-x86_64";
 const DEFAULT_INSTALL_AUTH_TIMEOUT_MS = 120_000;
 const PORTABLE_STUDIO_SERVER_READY_TIMEOUT_MS = 30_000;
 const PORTABLE_STUDIO_SERVER_READY_INTERVAL_MS = 250;
+const DOWNLOAD_STALL_TIMEOUT_MS = 30_000;
+const DOWNLOAD_PROGRESS_LOG_BYTES = 50 * 1024 * 1024;
 const MAX_WIDE_EVENT_PROCESS_ROOTS = 5;
 const MAX_NONCURRENT_MANAGED_DOWNLOADS = 0;
 const MAX_NONCURRENT_MANAGED_RELEASES = 0;
@@ -2123,13 +2125,10 @@ async function openStudio(options) {
         throw new Error("--download-only is only supported with `tapi studio install`.");
     }
     await ensureServiceReadyForStudio(options);
+    await closeExistingPortableStudioServersForFreshLaunch();
     if (!options.exePath) {
         const portable = await ensurePortableStudioServer(options);
         if (portable) {
-            const existing = await tryOpenExistingPortableStudioServer(options, portable.manifest);
-            if (existing.opened) {
-                return 0;
-            }
             await launchPortableStudioServer(portable.exePath, options, portable.manifest);
             return 0;
         }
@@ -2164,53 +2163,16 @@ function findStudioExecutable(options) {
     }
     return getStudioExecutableCandidates().find((candidate) => existsSync(candidate));
 }
-export async function tryOpenExistingPortableStudioServer(options, manifest, fetchImpl = fetch, openBrowserImpl = openBrowser) {
-    const record = await readStudioInstanceRecord(options);
-    if (!record) {
-        return { opened: false, reason: "instance_record_missing" };
-    }
-    if ((record.manifestVersion || "") !== manifest.version) {
-        return { opened: false, reason: "manifest_version_mismatch" };
-    }
-    try {
-        const identityResponse = await fetchWithTimeout(`${record.baseUrl.replace(/\/+$/, "")}/api/studio/control/identity`, { headers: { Accept: "application/json" } }, 1_000, fetchImpl);
-        if (!identityResponse.ok) {
-            await unlinkIfExists(studioInstanceRecordPathForOptions(options));
-            return { opened: false, reason: `identity_http_${identityResponse.status}` };
-        }
-        const identity = await readJsonBody(identityResponse);
-        if (!studioInstanceIdentityMatches(identity, options)) {
-            return { opened: false, reason: "identity_mismatch" };
-        }
-        const launchUrl = studioLaunchUrl(record.baseUrl, options);
-        await requestExistingStudioRuntimeCleanup(record.baseUrl, fetchImpl);
-        openBrowserImpl(launchUrl);
-        console.log(`Opened existing Tapi Studio ${record.manifestVersion || manifest.version}: ${launchUrl}`);
-        return { opened: true, baseUrl: record.baseUrl };
-    }
-    catch (error) {
-        await unlinkIfExists(studioInstanceRecordPathForOptions(options));
-        return { opened: false, reason: formatError(error) };
-    }
-}
-async function requestExistingStudioRuntimeCleanup(baseUrl, fetchImpl = fetch) {
-    const url = `${baseUrl.replace(/\/+$/, "")}/api/studio/control/cleanup-runtime-session`;
-    try {
-        const response = await fetchWithTimeout(url, {
-            method: "POST",
-            headers: {
-                Accept: "application/json",
-                "Content-Type": "application/json",
-            },
-            body: JSON.stringify({ reason: "tapi_studio_reopen" }),
-        }, 5_000, fetchImpl);
-        if (!response.ok && response.status !== 404) {
-            console.warn(`Tapi Studio runtime cleanup returned HTTP ${response.status}; opening Studio anyway.`);
-        }
+export async function closeExistingPortableStudioServersForFreshLaunch(stopProcesses = stopPortableStudioServerProcesses) {
+    const stopped = await stopProcesses();
+    const recordsRemoved = await clearStudioInstanceRecords();
+    if (stopped > 0) {
+        await delay(500);
     }
-    catch (error) {
-        console.warn(`Tapi Studio runtime cleanup failed: ${formatError(error)}. Opening Studio anyway.`);
+    if (stopped > 0 || recordsRemoved > 0) {
+        console.log(`Closed existing Tapi Studio servers before fresh launch: stopped=${stopped}, records=${recordsRemoved}`);
     }
+    return { stopped, recordsRemoved };
 }
 async function ensurePortableStudioServer(options) {
     const event = await createCliWideEvent("tapi_cli.studio_server_ensure", {
@@ -2490,6 +2452,53 @@ foreach ($pidValue in $owners.Keys) {
         return 0;
     }
 }
+async function stopPortableStudioServerProcesses() {
+    if (process.platform !== "win32") {
+        return 0;
+    }
+    const script = `
+$ErrorActionPreference = 'SilentlyContinue'
+$currentPid = $PID
+$processes = @(Get-CimInstance Win32_Process | Where-Object {
+  $pidValue = [int]$_.ProcessId
+  if ($pidValue -le 0 -or $pidValue -eq $currentPid) {
+    $false
+  } else {
+    $path = [string]$_.ExecutablePath
+    $cmd = [string]$_.CommandLine
+    $name = [string]$_.Name
+    (
+      $name -ieq 'tapi-studio-server.exe' -or
+      $path -match '\\\\Tapi\\\\Studio\\\\server\\\\releases\\\\' -or
+      $cmd -match 'tapi-studio-server' -or
+      $cmd -match 'scripts[\\\\/]studio\\.py'
+    )
+  }
+})
+$stopped = 0
+foreach ($process in $processes) {
+  try {
+    Stop-Process -Id ([int]$process.ProcessId) -Force -ErrorAction Stop
+    $stopped += 1
+  } catch {}
+}
+[pscustomobject]@{ stopped = $stopped } | ConvertTo-Json -Compress
+`;
+    try {
+        const output = await runProcessCapture("powershell.exe", [
+            "-NoProfile",
+            "-ExecutionPolicy",
+            "Bypass",
+            "-Command",
+            script,
+        ]);
+        const payload = JSON.parse(output.trim() || "{}");
+        return typeof payload.stopped === "number" ? payload.stopped : 0;
+    }
+    catch {
+        return 0;
+    }
+}
 async function runDoctor(options) {
     console.log(`Tapi SDK: ${sdkVersion}`);
     console.log(`Node: ${process.version}`);
@@ -2610,11 +2619,11 @@ async function requestStudioInstallToken(apiBaseUrl, channel, firebaseIdToken, f
         expiresAt: typeof payload?.expiresAt === "string" ? payload.expiresAt : undefined,
     };
 }
-export async function downloadAndVerify(url, destination, expectedSha256, label = "Studio installer") {
+export async function downloadAndVerify(url, destination, expectedSha256, label = "Studio installer", options = {}) {
     const partialPath = `${destination}.partial`;
     await unlinkIfExists(partialPath);
     try {
-        await downloadFile(url, partialPath, label);
+        await downloadFile(url, partialPath, label, options);
         const actualSha256 = await sha256File(partialPath);
         if (actualSha256 !== expectedSha256.toLowerCase()) {
             throw new Error(`${label} checksum mismatch. Expected ${expectedSha256}, got ${actualSha256}.`);
@@ -2627,15 +2636,97 @@ export async function downloadAndVerify(url, destination, expectedSha256, label
         throw error;
     }
 }
-async function downloadFile(url, destination, label = "download") {
-    const response = await fetch(url);
-    if (!response.ok) {
-        throw new Error(`Failed to download ${label}: HTTP ${response.status}`);
+async function downloadFile(url, destination, label = "download", options = {}) {
+    const stallTimeoutMs = normalizeDownloadTimeout(options.stallTimeoutMs);
+    const controller = new AbortController();
+    let stallTimer;
+    let stallError;
+    let source;
+    let progressStream;
+    let destinationStream;
+    let receivedBytes = 0;
+    let nextProgressLogBytes = DOWNLOAD_PROGRESS_LOG_BYTES;
+    const failIfStalled = (phase) => {
+        if (stallTimer) {
+            clearTimeout(stallTimer);
+        }
+        stallTimer = setTimeout(() => {
+            stallError = formatDownloadStallError(label, stallTimeoutMs, phase, receivedBytes);
+            controller.abort(stallError);
+            source?.destroy(stallError);
+            progressStream?.destroy(stallError);
+            destinationStream?.destroy(stallError);
+        }, stallTimeoutMs);
+    };
+    try {
+        console.log(`Downloading ${label}...`);
+        failIfStalled("connecting");
+        const response = await fetch(url, { signal: controller.signal });
+        if (!response.ok) {
+            throw new Error(`Failed to download ${label}: HTTP ${response.status}`);
+        }
+        if (!response.body) {
+            throw new Error(`${label} response did not include a body.`);
+        }
+        failIfStalled("receiving data");
+        source = Readable.fromWeb(response.body);
+        progressStream = new Transform({
+            transform(chunk, _encoding, callback) {
+                receivedBytes += downloadChunkByteLength(chunk);
+                failIfStalled("receiving data");
+                if (receivedBytes >= nextProgressLogBytes) {
+                    console.log(`Downloaded ${label}: ${formatBytes(receivedBytes)}...`);
+                    while (receivedBytes >= nextProgressLogBytes) {
+                        nextProgressLogBytes += DOWNLOAD_PROGRESS_LOG_BYTES;
+                    }
+                }
+                callback(null, chunk);
+            },
+        });
+        destinationStream = createWriteStream(destination);
+        await pipeline(source, progressStream, destinationStream);
+        console.log(`Downloaded ${label}: ${formatBytes(receivedBytes)}.`);
     }
-    if (!response.body) {
-        throw new Error(`${label} response did not include a body.`);
+    catch (error) {
+        if (stallError) {
+            throw stallError;
+        }
+        throw error;
+    }
+    finally {
+        if (stallTimer) {
+            clearTimeout(stallTimer);
+        }
     }
-    await pipeline(Readable.fromWeb(response.body), createWriteStream(destination));
+}
+function downloadChunkByteLength(chunk) {
+    if (typeof chunk === "string") {
+        return Buffer.byteLength(chunk);
+    }
+    if (Buffer.isBuffer(chunk)) {
+        return chunk.length;
+    }
+    if (chunk instanceof Uint8Array) {
+        return chunk.byteLength;
+    }
+    return 0;
+}
+function normalizeDownloadTimeout(timeoutMs) {
+    if (typeof timeoutMs !== "number" || !Number.isFinite(timeoutMs)) {
+        return DOWNLOAD_STALL_TIMEOUT_MS;
+    }
+    return Math.max(1, Math.floor(timeoutMs));
+}
+function formatDownloadStallError(label, timeoutMs, phase, receivedBytes) {
+    const progress = receivedBytes > 0 ? ` after ${formatBytes(receivedBytes)}` : "";
+    return new Error(`${label} download stalled${progress}: no data received for ${formatDuration(timeoutMs)} while ${phase}. ` +
+        "Check your network connection, VPN, or install authorization and retry.");
+}
+function formatDuration(ms) {
+    if (ms < 1000) {
+        return `${ms}ms`;
+    }
+    return `${Math.ceil(ms / 1000)}s`;
 }
 async function browserGoogleSignIn(timeoutMs = DEFAULT_INSTALL_AUTH_TIMEOUT_MS) {
     ensureWindowsHost();
@@ -2795,7 +2886,39 @@ export function studioInstanceRecordPathForOptions(options) {
     }))
         .digest("hex")
         .slice(0, 24);
-    return join(getDefaultTapiDataDir(), "Studio", "instances", `${key}.json`);
+    return join(studioInstanceRecordsDir(), `${key}.json`);
+}
+function studioInstanceRecordsDir() {
+    return join(getDefaultTapiDataDir(), "Studio", "instances");
+}
+async function clearStudioInstanceRecords() {
+    let entries;
+    try {
+        entries = await readdir(studioInstanceRecordsDir(), { withFileTypes: true });
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return 0;
+        }
+        throw error;
+    }
+    let removed = 0;
+    for (const entry of entries) {
+        if (!entry.isFile() || !entry.name.toLowerCase().endsWith(".json")) {
+            continue;
+        }
+        const path = join(studioInstanceRecordsDir(), entry.name);
+        try {
+            await unlink(path);
+            removed += 1;
+        }
+        catch (error) {
+            if (error.code !== "ENOENT") {
+                throw error;
+            }
+        }
+    }
+    return removed;
 }
 async function writeStudioInstanceRecord(options, record) {
     await writeJsonFile(studioInstanceRecordPathForOptions(options), record);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tapi-dev/sdk",
-  "version": "0.1.28",
+  "version": "0.1.30",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",