@tapi-dev/sdk 0.1.11 → 0.1.13

package/dist/cli.d.ts

@@ -71,12 +71,20 @@ export interface ServiceStatus {
     pathName?: string;
     installedVersion?: string;
 }
+type FetchLike = typeof fetch;
 export declare function runCli(argv?: string[]): Promise<number>;
 export declare function parseStudioOptions(args: string[]): StudioCliOptions;
 export declare function installedServiceVersionFromPathName(pathName: string): string | undefined;
 export declare function serviceNeedsInstall(status: ServiceStatus, manifest: ServiceReleaseManifest): boolean;
 export declare function getDefaultStudioCacheDir(): string;
 export declare function getDefaultServiceCacheDir(): string;
+interface ServiceInstallLogPaths {
+    logPath: string;
+    resultPath: string;
+}
+export declare function getDefaultServiceInstallLogDir(): string;
+export declare function serviceInstallLogPaths(version: string, now?: Date): ServiceInstallLogPaths;
+export declare function formatServiceInstallFailure(error: unknown, paths: ServiceInstallLogPaths): Promise<string>;
 export declare class CliWideEvent {
     private readonly filePath;
     private readonly startedAt;
@@ -94,5 +102,6 @@ export declare function getStudioExecutableCandidates(): string[];
 export declare function validateStudioManifest(input: unknown): StudioReleaseManifest;
 export declare function validateServiceReleaseManifest(input: unknown): ServiceReleaseManifest;
 export declare function compareVersions(left: string, right: string): number;
+export declare function waitForHttpOk(url: string, timeoutMs?: number, intervalMs?: number, fetchImpl?: FetchLike): Promise<void>;
 export declare function findPortableStudioServerExe(releaseDir: string, manifest: StudioReleaseManifest): string | undefined;
 export {};

package/dist/cli.js

@@ -4,7 +4,7 @@ import { createServer } from "node:http";
 import { createServer as createNetServer } from "node:net";
 import { createHash, randomUUID } from "node:crypto";
 import { createReadStream, createWriteStream, existsSync, readFileSync } from "node:fs";
-import { mkdir, readdir, rename, rm, stat, unlink, writeFile } from "node:fs/promises";
+import { mkdir, readFile, readdir, rename, rm, stat, unlink, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { basename, dirname, join, resolve } from "node:path";
 import { performance } from "node:perf_hooks";
@@ -20,6 +20,8 @@ const DEFAULT_FIREBASE_API_KEY = "AIzaSyCDZR8lWyVQcWYfFdNZa4vuL4IWEC0h6gE";
 const DEFAULT_CHANNEL = "pilot";
 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 MAX_WIDE_EVENT_PROCESS_ROOTS = 5;
 class StudioInstallApprovalError extends Error {
     code;
@@ -1028,10 +1030,19 @@ async function fetchServiceManifestForEnsure(options) {
         await event.finish(false, {
             error: errorDetails(error),
         });
+        if (isProtectedServiceManifestAuthError(error)) {
+            throw error;
+        }
         console.warn(`Could not check for Tapi Service updates: ${formatError(error)}`);
         return null;
     }
 }
+function isProtectedServiceManifestAuthError(error) {
+    const message = formatError(error);
+    return (message.includes("Failed to fetch protected Tapi Service manifest: HTTP 401")
+        || message.includes("Failed to fetch protected Tapi Service manifest: HTTP 403")
+        || message.includes("Worker bootstrap secret required"));
+}
 export function installedServiceVersionFromPathName(pathName) {
     const normalized = String(pathName || "").replace(/\\/g, "/");
     const parts = normalized
@@ -1131,23 +1142,36 @@ async function installService(options) {
         if (!existsSync(hostExe)) {
             throw new Error(`Tapi Service host executable was not found after extraction: ${hostExe}`);
         }
+        const installLog = serviceInstallLogPaths(manifest.version);
+        await mkdir(dirname(installLog.logPath), { recursive: true });
         console.log(`Installing Tapi Service ${manifest.version}...`);
         await event.phase("service_installer.start", {
             installer,
             hostExe,
             releaseDir,
+            logPath: installLog.logPath,
+            resultPath: installLog.resultPath,
         });
-        await runProcess("powershell.exe", [
-            "-NoProfile",
-            "-ExecutionPolicy",
-            "Bypass",
-            "-File",
-            installer,
-            "-ExecutablePath",
-            hostExe,
-            "-WorkingDirectory",
-            releaseDir,
-        ]);
+        try {
+            await runProcess("powershell.exe", [
+                "-NoProfile",
+                "-ExecutionPolicy",
+                "Bypass",
+                "-File",
+                installer,
+                "-ExecutablePath",
+                hostExe,
+                "-WorkingDirectory",
+                releaseDir,
+                "-LogPath",
+                installLog.logPath,
+                "-ResultPath",
+                installLog.resultPath,
+            ]);
+        }
+        catch (error) {
+            throw new Error(await formatServiceInstallFailure(error, installLog), { cause: error });
+        }
         await event.finish(true, {
             releaseDir,
             version: manifest.version,
@@ -1316,6 +1340,76 @@ export function getDefaultServiceCacheDir() {
     }
     return join(process.env.XDG_CACHE_HOME ?? join(homedir(), ".cache"), "tapi", "service");
 }
+export function getDefaultServiceInstallLogDir() {
+    return join(getDefaultServiceCacheDir(), "logs");
+}
+export function serviceInstallLogPaths(version, now = new Date()) {
+    const stamp = now.toISOString().replace(/[:.]/g, "-");
+    const safeVersion = safePathSegment(version);
+    return {
+        logPath: join(getDefaultServiceInstallLogDir(), `install-${safeVersion}-${stamp}.log`),
+        resultPath: join(getDefaultServiceInstallLogDir(), `install-${safeVersion}-${stamp}.json`),
+    };
+}
+export async function formatServiceInstallFailure(error, paths) {
+    const lines = [
+        `Tapi Service installer failed: ${formatError(error)}`,
+        `Install log: ${paths.logPath}`,
+        `Install result: ${paths.resultPath}`,
+    ];
+    const result = await readServiceInstallResult(paths.resultPath);
+    if (result) {
+        const phase = installerStringField(result.phase);
+        const installError = installerStringField(result.error);
+        const exitCode = result.exitCode !== undefined ? String(result.exitCode) : "";
+        if (phase || exitCode) {
+            lines.push(`Installer result: phase=${phase || "unknown"} exitCode=${exitCode || "unknown"}`);
+        }
+        if (installError) {
+            lines.push(`Installer error: ${installError}`);
+        }
+        const resultLogPath = installerStringField(result.logPath);
+        if (resultLogPath && resultLogPath !== paths.logPath) {
+            lines.push(`Installer-reported log: ${resultLogPath}`);
+        }
+    }
+    const logText = await readTextFileIfExists(paths.logPath);
+    if (logText?.trim()) {
+        const tail = tailLines(logText, 30);
+        if (tail.length > 0) {
+            lines.push("Last installer log lines:");
+            lines.push(...tail.map((line) => `  ${line}`));
+        }
+    }
+    return lines.join("\n");
+}
+async function readServiceInstallResult(path) {
+    const text = await readTextFileIfExists(path);
+    if (!text) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(text);
+        return parsed && typeof parsed === "object" ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function readTextFileIfExists(path) {
+    try {
+        return await readFile(path, "utf8");
+    }
+    catch {
+        return null;
+    }
+}
+function installerStringField(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function tailLines(text, count) {
+    return text.split(/\r?\n/).filter((line) => line.trim()).slice(-count);
+}
 export class CliWideEvent {
     filePath;
     startedAt = performance.now();
@@ -1844,9 +1938,36 @@ async function launchPortableStudioServer(exePath, options) {
     });
     child.unref();
     const url = `http://${host}:${port}`;
+    await waitForHttpOk(`${url}/healthz`, PORTABLE_STUDIO_SERVER_READY_TIMEOUT_MS, PORTABLE_STUDIO_SERVER_READY_INTERVAL_MS);
     openBrowser(url);
     console.log(`Opened Tapi Studio: ${url}`);
 }
+export async function waitForHttpOk(url, timeoutMs = PORTABLE_STUDIO_SERVER_READY_TIMEOUT_MS, intervalMs = PORTABLE_STUDIO_SERVER_READY_INTERVAL_MS, fetchImpl = fetch) {
+    const startedAt = performance.now();
+    let lastError = "";
+    while (performance.now() - startedAt < timeoutMs) {
+        try {
+            const response = await fetchImpl(url, {
+                headers: { Accept: "application/json" },
+            });
+            if (response.ok) {
+                return;
+            }
+            lastError = `HTTP ${response.status}`;
+        }
+        catch (error) {
+            lastError = formatError(error);
+        }
+        await delay(intervalMs);
+    }
+    const suffix = lastError ? ` Last error: ${lastError}.` : "";
+    throw new Error(`Tapi Studio server did not become ready at ${url} within ${Math.ceil(timeoutMs / 1000)}s.${suffix}`);
+}
+function delay(ms) {
+    return new Promise((resolvePromise) => {
+        setTimeout(resolvePromise, Math.max(0, ms));
+    });
+}
 async function chooseStudioPort(preferred = 18766) {
     for (let port = preferred; port < preferred + 25; port += 1) {
         if (await isPortAvailable(port)) {

package/package.json

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