@tapi-dev/sdk 0.1.24 → 0.1.26

package/dist/cli.d.ts

@@ -114,6 +114,11 @@ 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 findPortablePlaywrightBrowsersDir(exePath: string): string | undefined;
 export declare function waitForHttpOk(url: string, timeoutMs?: number, intervalMs?: number, fetchImpl?: FetchLike): Promise<void>;
 export declare function chooseStudioPort(preferred?: number, options?: {

package/dist/cli.js

@@ -2126,6 +2126,10 @@ async function openStudio(options) {
     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;
         }
@@ -2160,6 +2164,34 @@ 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);
+        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 ensurePortableStudioServer(options) {
     const event = await createCliWideEvent("tapi_cli.studio_server_ensure", {
         sdk_version: sdkVersion,
@@ -2259,8 +2291,7 @@ async function launchPortableStudioServer(exePath, options, manifest) {
         env.PLAYWRIGHT_BROWSERS_PATH = playwrightBrowsersPath;
     }
     const url = `http://${host}:${port}`;
-    const launchQuery = options.launchUrlQuery ? options.launchUrlQuery.replace(/^\?+/, "") : "";
-    const launchUrl = launchQuery ? `${url}/?${launchQuery}` : url;
+    const launchUrl = studioLaunchUrl(url, options);
     let childPid = 0;
     await withCliSpinner("Starting Tapi Studio", async () => {
         const child = spawn(exePath, [], {
@@ -2289,6 +2320,11 @@ async function launchPortableStudioServer(exePath, options, manifest) {
     openBrowser(launchUrl);
     console.log(`Opened Tapi Studio ${manifest.version}: ${launchUrl}`);
 }
+function studioLaunchUrl(baseUrl, options) {
+    const normalizedBaseUrl = baseUrl.replace(/\/+$/, "");
+    const launchQuery = options.launchUrlQuery ? options.launchUrlQuery.replace(/^\?+/, "") : "";
+    return launchQuery ? `${normalizedBaseUrl}/?${launchQuery}` : normalizedBaseUrl;
+}
 export function findPortablePlaywrightBrowsersDir(exePath) {
     const exeDir = dirname(exePath);
     const releaseDir = basename(exeDir).toLowerCase() === "tapi-studio-server"
@@ -2444,14 +2480,16 @@ async function runDoctor(options) {
     console.log(`Studio cache: ${options.cacheDir}`);
     console.log(`Workspace: ${options.workspaceRoot ?? "not found"}`);
     console.log(`Project: ${options.projectId ?? "not set"}`);
-    const exePath = options.exePath ?? getStudioExecutableCandidates().find((candidate) => existsSync(candidate));
-    console.log(`Studio executable: ${exePath && existsSync(exePath) ? exePath : "not found"}`);
     try {
         const manifest = await withCliSpinner("Fetching latest Tapi Studio manifest", () => fetchStudioManifest(options.manifestUrl));
         ensureCompatibleManifest(manifest);
+        const exePath = findInstalledStudioExecutable(options, manifest);
+        console.log(`Studio executable: ${exePath ?? "not found"}`);
         console.log(`Latest Studio: ${manifest.version} (${manifest.platform})`);
     }
     catch (error) {
+        const exePath = options.exePath ?? getStudioExecutableCandidates().find((candidate) => existsSync(candidate));
+        console.log(`Studio executable: ${exePath && existsSync(exePath) ? exePath : "not found"}`);
         console.log(`Latest Studio: unavailable (${formatError(error)})`);
         return 1;
     }
@@ -2920,6 +2958,19 @@ function isPortableStudioServerManifest(manifest) {
     const kind = String(manifest.installerKind || "").toLowerCase();
     return kind === "portable-server" || manifest.artifactName.toLowerCase().endsWith(".zip");
 }
+function findInstalledStudioExecutable(options, manifest) {
+    if (options.exePath) {
+        return existsSync(options.exePath) ? options.exePath : undefined;
+    }
+    const legacyDesktopExe = getStudioExecutableCandidates().find((candidate) => existsSync(candidate));
+    if (legacyDesktopExe) {
+        return legacyDesktopExe;
+    }
+    if (!isPortableStudioServerManifest(manifest)) {
+        return undefined;
+    }
+    return findPortableStudioServerExe(portableStudioServerReleaseDir(manifest, options.installDir), manifest);
+}
 function portableStudioServerReleaseDir(manifest, releasesDir = getDefaultPortableStudioServerReleasesDir()) {
     return join(releasesDir, safePathSegment(manifest.version));
 }

package/package.json

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