@tapi-dev/sdk 0.1.38 → 0.1.39

package/README.md

@@ -13,20 +13,32 @@ This package is ESM-first and works in runtimes with `fetch`, including modern N
 The CLI command is `tapi`. If your package manager only installed the SDK
 locally and `tapi` is not on `PATH`, use `npx tapi` as a fallback.
 
-## Developer Flow
-
-Tapi Studio is launched from the developer app repo. The repo's `.tapi/project.json`
-is the project binding, so one developer can work on multiple Tapi projects from
-different directories without a global Studio project picker.
-
-```bash
-npm install @tapi-dev/sdk
-tapi init --project brokerage
-tapi studio
-```
-
-`tapi studio` checks the required local `tapi-service`, installs it when needed,
-downloads the portable Studio server release when the channel manifest uses
+## Developer Flow
+
+Tapi Studio is launched from the signed-in developer account. Running
+`tapi studio` lists the Tapps available to that account, asks which one to open,
+then starts Studio in that Tapp context. The current directory can still provide
+a default via `.tapi/project.json`, but it is no longer required for Studio to
+know which Tapp to show.
+
+```bash
+npm install @tapi-dev/sdk
+tapi login
+tapi tapp create brokerage
+tapi studio
+```
+
+Useful Studio launch forms:
+
+```bash
+tapi studio                    # ask which Tapp to open
+tapi studio --tapp brokerage   # open one Tapp directly
+tapi studio --select           # force the picker
+tapi studio --last             # reuse the last selected Tapp
+```
+
+`tapi studio` checks the required local `tapi-service`, installs it when needed,
+downloads the portable Studio server release when the channel manifest uses
 `installerKind: portable-server`, starts Studio locally, and opens the browser.
 If the channel still publishes a legacy NSIS desktop Studio manifest and no
 Studio executable is installed yet, `tapi studio` runs the installer first, then
@@ -57,6 +69,7 @@ tapi login
 tapi init --project brokerage
 tapi link --project brokerage
 tapi studio
+tapi studio --tapp brokerage
 tapi service install --channel pilot
 tapi service status
 tapi services describe schwab.place_order

package/dist/cli.d.ts

@@ -66,8 +66,10 @@ export interface StudioCliOptions {
     workspaceRoot?: string;
     projectId?: string;
     projectSlug?: string;
+    projectIdSource?: "option" | "env" | "workspace" | "selection";
     workspaceMode: boolean;
     launchUrlQuery?: string;
+    tappSelectionMode: "auto" | "select" | "last" | "none";
 }
 export interface RunnerSetupCliOptions {
     apiBaseUrl: string;

package/dist/cli.js

@@ -12,6 +12,9 @@ import { emitKeypressEvents } from "node:readline";
 import { Readable, Transform } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import { fileURLToPath, pathToFileURL } from "node:url";
+import { select } from "@inquirer/prompts";
+import { Presets, SingleBar } from "cli-progress";
+import pc from "yoctocolors";
 import { TapiClient } from "./index.js";
 import { loadWorkspace, normalizeProjectValue, writeWorkspaceConfig, } from "./workspace.js";
 const DEFAULT_DOWNLOADS_BASE_URL = "https://d4xaf52nfwiok.cloudfront.net";
@@ -314,6 +317,9 @@ export async function runCli(argv = process.argv.slice(2)) {
     if (!subcommand) {
         return openStudio(parseStudioOptions([]));
     }
+    if (subcommand.startsWith("-")) {
+        return openStudio(parseStudioOptions([subcommand, ...rest]));
+    }
     if (subcommand === "help" || subcommand === "--help" || subcommand === "-h") {
         printStudioHelp();
         return 0;
@@ -340,6 +346,8 @@ export function parseStudioOptions(args) {
     const raw = {};
     let workspaceSearchRoot;
     let skipWorkspace = false;
+    let projectIdSource;
+    let tappSelectionMode = "auto";
     for (let index = 0; index < args.length; index += 1) {
         const arg = args[index];
         if (!arg) {
@@ -385,12 +393,40 @@ export function parseStudioOptions(args) {
             skipWorkspace = true;
             continue;
         }
+        if (arg === "--tapp") {
+            raw.projectId = normalizeProjectValue(requireOptionValue(args, ++index, "--tapp"), "tapp");
+            projectIdSource = "option";
+            tappSelectionMode = "none";
+            continue;
+        }
+        if (arg.startsWith("--tapp=")) {
+            raw.projectId = normalizeProjectValue(arg.slice("--tapp=".length), "tapp");
+            projectIdSource = "option";
+            tappSelectionMode = "none";
+            continue;
+        }
+        if (arg === "--select") {
+            tappSelectionMode = "select";
+            continue;
+        }
+        if (arg === "--last") {
+            tappSelectionMode = "last";
+            continue;
+        }
+        if (arg === "--no-select") {
+            tappSelectionMode = "none";
+            continue;
+        }
         if (arg === "--project") {
             raw.projectId = normalizeProjectValue(requireOptionValue(args, ++index, "--project"), "project");
+            projectIdSource = "option";
+            tappSelectionMode = "none";
             continue;
         }
         if (arg.startsWith("--project=")) {
             raw.projectId = normalizeProjectValue(arg.slice("--project=".length), "project");
+            projectIdSource = "option";
+            tappSelectionMode = "none";
             continue;
         }
         if (arg === "--project-slug") {
@@ -459,7 +495,11 @@ export function parseStudioOptions(args) {
     const manifestUrl = explicitManifestUrl
         ? normalizeHttpUrl(explicitManifestUrl, "Studio manifest URL")
         : `${downloadsBaseUrl.replace(/\/+$/, "")}/studio/channels/${channel}/latest.json`;
-    const projectId = raw.projectId ?? envString("TAPI_PROJECT_ID") ?? workspace?.projectId;
+    const envProjectId = envString("TAPI_PROJECT_ID");
+    const projectId = raw.projectId ?? envProjectId ?? workspace?.projectId;
+    if (!projectIdSource && projectId) {
+        projectIdSource = raw.projectId ? "option" : envProjectId ? "env" : "workspace";
+    }
     const projectSlug = raw.projectSlug ?? envString("TAPI_PROJECT_SLUG") ?? workspace?.projectSlug;
     const envInstallToken = envString("TAPI_STUDIO_INSTALL_TOKEN");
     const installToken = raw.installToken ?? envInstallToken;
@@ -479,7 +519,9 @@ export function parseStudioOptions(args) {
         workspaceRoot: workspace?.root,
         projectId,
         projectSlug,
+        projectIdSource,
         workspaceMode: Boolean(projectId || workspace),
+        tappSelectionMode,
     };
 }
 function parseServiceOptions(args) {
@@ -2342,7 +2384,7 @@ async function installService(options) {
                 destination: zipPath,
                 expectedSha256: manifest.sha256,
             });
-            await withCliSpinner(`Downloading Tapi Service ${manifest.version}`, () => downloadAndVerify(manifest.url, zipPath, manifest.sha256, "Tapi Service artifact"));
+            await downloadAndVerify(manifest.url, zipPath, manifest.sha256, "Tapi Service artifact");
             await event.phase("download.verified", {
                 zipPath,
                 expectedSha256: manifest.sha256,
@@ -2797,7 +2839,7 @@ async function installStudio(options) {
                 destination: installerPath,
                 expectedSha256: manifest.sha256,
             });
-            await withCliSpinner(`Downloading Tapi Studio ${manifest.version}`, () => downloadAndVerify(manifest.url, installerPath, manifest.sha256));
+            await downloadAndVerify(manifest.url, installerPath, manifest.sha256);
             await event.phase("download.verified", {
                 installerPath,
                 expectedSha256: manifest.sha256,
@@ -2950,23 +2992,24 @@ async function openStudio(options) {
     if (options.downloadOnly) {
         throw new Error("--download-only is only supported with `tapi studio install`.");
     }
-    await ensureServiceReadyForStudio(options);
+    const launchOptions = await resolveStudioTappSelection(options);
+    await ensureServiceReadyForStudio(launchOptions);
     await closeExistingPortableStudioServersForFreshLaunch();
-    if (!options.exePath) {
-        const portable = await ensurePortableStudioServer(options);
+    if (!launchOptions.exePath) {
+        const portable = await ensurePortableStudioServer(launchOptions);
         if (portable) {
-            await launchPortableStudioServer(portable.exePath, options, portable.manifest);
+            await launchPortableStudioServer(portable.exePath, launchOptions, portable.manifest);
             return 0;
         }
     }
-    let exePath = findStudioExecutable(options);
-    if (!exePath && !options.exePath) {
+    let exePath = findStudioExecutable(launchOptions);
+    if (!exePath && !launchOptions.exePath) {
         console.log("Tapi Studio executable was not found. Installing Tapi Studio now...");
-        const installCode = await installStudio(options);
+        const installCode = await installStudio(launchOptions);
         if (installCode !== 0) {
             return installCode;
         }
-        exePath = findStudioExecutable(options);
+        exePath = findStudioExecutable(launchOptions);
     }
     if (!exePath || !existsSync(exePath)) {
         console.error("Tapi Studio executable was not found.");
@@ -2975,7 +3018,7 @@ async function openStudio(options) {
     }
     const child = spawn(exePath, [], {
         detached: true,
-        env: buildStudioLaunchEnv(options),
+        env: buildStudioLaunchEnv(launchOptions),
         stdio: "ignore",
         windowsHide: false,
     });
@@ -2983,6 +3026,177 @@ async function openStudio(options) {
     console.log(`Opened Tapi Studio: ${exePath}`);
     return 0;
 }
+async function resolveStudioTappSelection(options) {
+    if (options.tappSelectionMode === "none") {
+        return options.projectId ? await rememberSelectedStudioTapp(options, options.projectId) : options;
+    }
+    if (options.tappSelectionMode === "auto" && options.projectIdSource === "env" && options.projectId) {
+        return await rememberSelectedStudioTapp(options, options.projectId);
+    }
+    const lastSelection = await readStudioSelectionRecord();
+    if (options.tappSelectionMode === "last") {
+        if (!lastSelection?.lastTappId) {
+            throw new Error("No previous Studio Tapp selection exists. Run `tapi studio --select` or `tapi studio --tapp <tapp>`.");
+        }
+        return await rememberSelectedStudioTapp(options, lastSelection.lastTappId);
+    }
+    let tapps = [];
+    try {
+        const authenticated = await withSdkAuth({ authToken: undefined });
+        tapps = await fetchAvailableTappsForStudio(options, authenticated.authToken);
+    }
+    catch (error) {
+        if (options.projectId) {
+            console.warn(`Could not load Tapp list (${formatError(error)}). Opening Studio with ${options.projectId}.`);
+            return await rememberSelectedStudioTapp(options, options.projectId);
+        }
+        throw error;
+    }
+    if (!tapps.length) {
+        if (options.projectId) {
+            return await rememberSelectedStudioTapp(options, options.projectId);
+        }
+        throw new Error("No Tapps found for this account. Create one with `tapi tapp create <name>`, then run `tapi studio`.");
+    }
+    const preferred = preferredStudioTappId(options, lastSelection, tapps);
+    if (!studioTappPickerEnabled()) {
+        const selected = options.projectId
+            || lastSelection?.lastTappId
+            || (tapps.length === 1 ? tapps[0]?.tappId : "");
+        if (!selected) {
+            throw new Error("Multiple Tapps are available. Use `tapi studio --tapp <tapp>` or run in an interactive terminal.");
+        }
+        return await rememberSelectedStudioTapp(options, selected);
+    }
+    const selected = await select({
+        message: "Select Tapp",
+        choices: tapps.map((tapp) => ({
+            name: formatTappChoice(tapp),
+            value: tapp.tappId,
+        })),
+        default: preferred || tapps[0]?.tappId,
+    });
+    return await rememberSelectedStudioTapp(options, selected);
+}
+async function fetchAvailableTappsForStudio(options, authToken, fetchImpl = fetch) {
+    const response = await fetchImpl(`${options.apiBaseUrl.replace(/\/+$/, "")}/api/sdk/v1/tapps`, {
+        method: "GET",
+        headers: sdkJsonHeaders(authToken, options.projectId),
+    });
+    const body = await readJsonBody(response);
+    if (!response.ok) {
+        throw new Error(`Failed to list Tapps: HTTP ${response.status}`);
+    }
+    return normalizeTappList(body);
+}
+function normalizeTappList(body) {
+    const raw = isRecord(body) && Array.isArray(body.tapps) ? body.tapps : [];
+    const seen = new Set();
+    const tapps = [];
+    for (const item of raw) {
+        if (!isRecord(item)) {
+            continue;
+        }
+        const tappId = typeof item.tappId === "string" ? item.tappId.trim() : "";
+        if (!tappId || seen.has(tappId)) {
+            continue;
+        }
+        seen.add(tappId);
+        tapps.push({
+            tappId,
+            name: typeof item.name === "string" && item.name.trim() ? item.name.trim() : tappId,
+            serviceCount: normalizeNonnegativeInteger(item.serviceCount),
+            queueCount: normalizeNonnegativeInteger(item.queueCount),
+        });
+    }
+    return tapps;
+}
+function normalizeNonnegativeInteger(value) {
+    const number = typeof value === "number" ? value : Number(value);
+    return Number.isFinite(number) && number > 0 ? Math.floor(number) : 0;
+}
+function preferredStudioTappId(options, lastSelection, tapps) {
+    const candidates = [
+        options.projectId,
+        lastSelection?.lastTappId,
+        tapps[0]?.tappId,
+    ].map((value) => String(value || "").trim()).filter(Boolean);
+    const available = new Set(tapps.map((tapp) => tapp.tappId));
+    return candidates.find((candidate) => available.has(candidate)) || "";
+}
+function formatTappChoice(tapp) {
+    const details = [
+        `${tapp.serviceCount} service${tapp.serviceCount === 1 ? "" : "s"}`,
+        `${tapp.queueCount} queue${tapp.queueCount === 1 ? "" : "s"}`,
+    ].join(", ");
+    return tapp.name === tapp.tappId
+        ? `${tapp.tappId} ${pc.dim(`(${details})`)}`
+        : `${tapp.name} ${pc.dim(`${tapp.tappId} (${details})`)}`;
+}
+function studioTappPickerEnabled() {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        return false;
+    }
+    const raw = String(process.env.TAPI_STUDIO_TAPP_PICKER || "").trim().toLowerCase();
+    if (["0", "false", "no", "off"].includes(raw)) {
+        return false;
+    }
+    return true;
+}
+async function rememberSelectedStudioTapp(options, tappId) {
+    const selected = normalizeProjectValue(tappId, "tapp");
+    const projectSlug = options.projectId === selected && options.projectSlug
+        ? options.projectSlug
+        : selected;
+    await writeStudioSelectionRecord(selected);
+    return {
+        ...options,
+        projectId: selected,
+        projectSlug,
+        projectIdSource: "selection",
+        workspaceMode: true,
+        launchUrlQuery: studioLaunchQueryWithProject(options.launchUrlQuery, selected),
+    };
+}
+function studioLaunchQueryWithProject(query, projectId) {
+    const params = new URLSearchParams(String(query || "").replace(/^\?+/, ""));
+    params.set("project", projectId);
+    return params.toString();
+}
+async function readStudioSelectionRecord() {
+    try {
+        const payload = JSON.parse(await readFile(studioSelectionRecordPath(), "utf8"));
+        if (!isRecord(payload) || payload.version !== 1) {
+            return null;
+        }
+        const lastTappId = typeof payload.lastTappId === "string" ? payload.lastTappId.trim() : "";
+        if (!lastTappId) {
+            return null;
+        }
+        return {
+            version: 1,
+            lastTappId,
+            updatedAt: typeof payload.updatedAt === "string" ? payload.updatedAt : "",
+        };
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return null;
+        }
+        return null;
+    }
+}
+async function writeStudioSelectionRecord(tappId) {
+    await mkdir(getDefaultTapiDataDir(), { recursive: true });
+    await writeJsonFile(studioSelectionRecordPath(), {
+        version: 1,
+        lastTappId: tappId,
+        updatedAt: new Date().toISOString(),
+    });
+}
+function studioSelectionRecordPath() {
+    return join(getDefaultTapiDataDir(), "studio-selection.json");
+}
 function findStudioExecutable(options) {
     if (options.exePath) {
         return existsSync(options.exePath) ? options.exePath : undefined;
@@ -3053,7 +3267,7 @@ async function installPortableStudioServer(options, manifest, event) {
             destination: artifactPath,
             expectedSha256: manifest.sha256,
         });
-        await withCliSpinner(`Downloading Tapi Studio server ${manifest.version}`, () => downloadAndVerify(manifest.url, artifactPath, manifest.sha256, "Tapi Studio server artifact"));
+        await downloadAndVerify(manifest.url, artifactPath, manifest.sha256, "Tapi Studio server artifact");
         await event.phase("download.verified", {
             artifactPath,
             expectedSha256: manifest.sha256,
@@ -3115,6 +3329,7 @@ async function launchPortableStudioServer(exePath, options, manifest) {
         pid: childPid || undefined,
         apiBaseUrl: options.apiBaseUrl,
         projectId: options.projectId,
+        tappId: options.projectId,
         workspaceRoot: options.workspaceRoot,
         workspaceConfig: options.workspace?.configPath,
         manifestVersion: manifest.version,
@@ -3420,6 +3635,8 @@ async function downloadFile(url, destination, label = "download", options = {})
     let destinationStream;
     let receivedBytes = 0;
     let nextProgressLogBytes = DOWNLOAD_PROGRESS_LOG_BYTES;
+    let progressBar;
+    let expectedBytes = 0;
     const failIfStalled = (phase) => {
         if (stallTimer) {
             clearTimeout(stallTimer);
@@ -3433,7 +3650,6 @@ async function downloadFile(url, destination, label = "download", options = {})
         }, stallTimeoutMs);
     };
     try {
-        console.log(`Downloading ${label}...`);
         failIfStalled("connecting");
         const response = await fetch(url, { signal: controller.signal });
         if (!response.ok) {
@@ -3443,12 +3659,29 @@ async function downloadFile(url, destination, label = "download", options = {})
             throw new Error(`${label} response did not include a body.`);
         }
         failIfStalled("receiving data");
+        expectedBytes = parseContentLength(typeof response.headers?.get === "function" ? response.headers.get("content-length") : null);
+        progressBar = createDownloadProgressBar(label, expectedBytes);
+        if (progressBar) {
+            progressBar.start(expectedBytes, 0, {
+                value: formatBytes(0),
+                total: formatBytes(expectedBytes),
+            });
+        }
+        else {
+            console.log(`Downloading ${label}...`);
+        }
         source = Readable.fromWeb(response.body);
         progressStream = new Transform({
             transform(chunk, _encoding, callback) {
                 receivedBytes += downloadChunkByteLength(chunk);
                 failIfStalled("receiving data");
-                if (receivedBytes >= nextProgressLogBytes) {
+                if (progressBar) {
+                    progressBar.update(Math.min(receivedBytes, expectedBytes), {
+                        value: formatBytes(receivedBytes),
+                        total: formatBytes(expectedBytes),
+                    });
+                }
+                else if (receivedBytes >= nextProgressLogBytes) {
                     console.log(`Downloaded ${label}: ${formatBytes(receivedBytes)}...`);
                     while (receivedBytes >= nextProgressLogBytes) {
                         nextProgressLogBytes += DOWNLOAD_PROGRESS_LOG_BYTES;
@@ -3459,9 +3692,23 @@ async function downloadFile(url, destination, label = "download", options = {})
         });
         destinationStream = createWriteStream(destination);
         await pipeline(source, progressStream, destinationStream);
-        console.log(`Downloaded ${label}: ${formatBytes(receivedBytes)}.`);
+        if (progressBar) {
+            progressBar.update(expectedBytes, {
+                value: formatBytes(receivedBytes),
+                total: formatBytes(expectedBytes),
+            });
+            progressBar.stop();
+            progressBar = undefined;
+        }
+        else {
+            console.log(`Downloaded ${label}: ${formatBytes(receivedBytes)}.`);
+        }
     }
     catch (error) {
+        if (progressBar) {
+            progressBar.stop();
+            progressBar = undefined;
+        }
         if (stallError) {
             throw stallError;
         }
@@ -3717,6 +3964,7 @@ async function readStudioInstanceRecord(options) {
             pid: typeof parsed.pid === "number" && Number.isFinite(parsed.pid) ? parsed.pid : undefined,
             apiBaseUrl: typeof parsed.apiBaseUrl === "string" ? parsed.apiBaseUrl : "",
             projectId: typeof parsed.projectId === "string" ? parsed.projectId : undefined,
+            tappId: typeof parsed.tappId === "string" ? parsed.tappId : undefined,
             workspaceRoot: typeof parsed.workspaceRoot === "string" ? parsed.workspaceRoot : undefined,
             workspaceConfig: typeof parsed.workspaceConfig === "string" ? parsed.workspaceConfig : undefined,
             manifestVersion: typeof parsed.manifestVersion === "string" ? parsed.manifestVersion : undefined,
@@ -3842,6 +4090,31 @@ async function readJsonBody(response) {
         return null;
     }
 }
+function createDownloadProgressBar(label, totalBytes) {
+    if (!downloadProgressEnabled() || totalBytes <= 0) {
+        return undefined;
+    }
+    return new SingleBar({
+        format: `${label} |{bar}| {percentage}% | {value}/{total}`,
+        stream: process.stderr,
+        clearOnComplete: false,
+        hideCursor: true,
+        barsize: 32,
+        barCompleteChar: "#",
+        barIncompleteChar: "-",
+    }, Presets.shades_classic);
+}
+function downloadProgressEnabled() {
+    const raw = String(process.env.TAPI_CLI_PROGRESS || "").trim().toLowerCase();
+    if (["0", "false", "no", "off"].includes(raw)) {
+        return false;
+    }
+    return Boolean(process.stderr.isTTY);
+}
+function parseContentLength(value) {
+    const parsed = Number(value || "");
+    return Number.isFinite(parsed) && parsed > 0 ? Math.floor(parsed) : 0;
+}
 async function readRequestJson(request) {
     let body = "";
     for await (const chunk of request) {
@@ -4299,6 +4572,9 @@ function installEventOptions(options) {
         downloadOnly: options.downloadOnly,
         silent: options.silent,
         exePath: options.exePath,
+        projectId: options.projectId,
+        projectIdSource: options.projectIdSource,
+        tappSelectionMode: options.tappSelectionMode,
         installTokenProvided: Boolean(options.installToken),
         installTokenSource: options.installTokenSource,
     };
@@ -4429,8 +4705,10 @@ Usage:
   tapi login
   tapi init --project PROJECT
   tapi link --project PROJECT
-  tapi studio install [--channel pilot] [--api-base-url URL]
-  tapi studio
+  tapi studio install [--channel pilot] [--api-base-url URL]
+  tapi studio
+  tapi studio --tapp <tapp>
+  tapi studio --select
   tapi studio open
   tapi studio doctor
   tapi tapp create <tapp>
@@ -4451,8 +4729,8 @@ Commands:
   init            Create .tapi/project.json for this repo
   link            Rebind this repo to an existing Tapi project
   studio install  Download, verify, and run the Tapi Studio installer
-  studio          Open Tapi Studio for this repo
-  studio open     Open Tapi Studio for this repo
+  studio          Open Tapi Studio for a selected Tapp
+  studio open     Open Tapi Studio for a selected Tapp
   studio doctor   Check local SDK and Studio release configuration
   tapp create     Create a Tapp
   queue create    Create a queue for service-run routing
@@ -4591,14 +4869,18 @@ Usage:
   tapi studio open [options]
   tapi studio doctor [options]
 
-Options:
-  --channel <name>       Release channel: pilot, stable, or nightly
-  --api-base-url <url>   Tapi API base URL for install authorization and protected downloads
-  --server <url>         Alias for --api-base-url
-  --workspace <path>     Search this directory for .tapi/project.json
-  --no-workspace         Do not load .tapi/project.json
-  --project <id>         Tapi project id for workspace-bound Studio
-  --project-slug <slug>  Optional display slug for the bound project
+Options:
+  --channel <name>       Release channel: pilot, stable, or nightly
+  --api-base-url <url>   Tapi API base URL for install authorization and protected downloads
+  --server <url>         Alias for --api-base-url
+  --tapp <id>            Open this Tapp directly
+  --select               Force the account Tapp picker
+  --last                 Reuse the last selected Tapp
+  --no-select            Skip the picker and use env/workspace/default context
+  --workspace <path>     Search this directory for .tapi/project.json
+  --no-workspace         Do not load .tapi/project.json
+  --project <id>         Alias for --tapp
+  --project-slug <slug>  Optional display slug for the bound project
   --install-token <tok>  Preissued Studio install token (skips browser sign-in)
   --manifest <url>       Exact release manifest URL for doctor only
   --cache-dir <path>     Installer download cache directory

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tapi-dev/sdk",
-  "version": "0.1.38",
+  "version": "0.1.39",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -29,9 +29,15 @@
     "access": "public"
   },
   "devDependencies": {
+    "@types/cli-progress": "^3.11.6",
     "@types/node": "^20.0.0",
     "typescript": "^5.5.0",
     "vite": "6.4.3",
     "vitest": "^4.1.8"
+  },
+  "dependencies": {
+    "@inquirer/prompts": "^7.10.1",
+    "cli-progress": "^3.12.0",
+    "yoctocolors": "^2.1.2"
   }
 }