@tapi-dev/sdk 0.1.28 → 0.1.29

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>;

package/dist/cli.js

@@ -2123,13 +2123,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 +2161,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 +2450,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}`);
@@ -2795,7 +2802,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.29",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",