@tapi-dev/sdk 0.1.40 → 0.1.44

package/dist/studio-dev.d.ts

@@ -0,0 +1 @@
+export declare function openStudioDev(args: string[]): Promise<number>;

package/dist/studio-dev.js

@@ -0,0 +1,312 @@
+import { spawn } from "node:child_process";
+import { createServer } from "node:net";
+import { existsSync, readFileSync } from "node:fs";
+import { mkdir, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+const DEFAULT_API_BASE_URL = "https://determined-motivation-production.up.railway.app";
+const DEFAULT_FIREBASE_API_KEY = "AIzaSyCDZR8lWyVQcWYfFdNZa4vuL4IWEC0h6gE";
+const READY_TIMEOUT_MS = 120_000;
+export async function openStudioDev(args) {
+    if (args.includes("--help") || args.includes("-h")) {
+        printStudioDevHelp();
+        return 0;
+    }
+    const children = [];
+    let stopping = false;
+    try {
+        const options = parseDevOptions(args);
+        const phases = [{ message: "SDK development launch requested" }];
+        const workspaceRoot = findWorkspaceRoot(options.workspaceRoot || process.cwd());
+        const uiRoot = join(workspaceRoot, "tapi_v2", "plugins", "studio_ui_output", "shell", "react");
+        const python = findWorkspacePython(workspaceRoot);
+        const auth = await refreshAuthRecord();
+        const tappId = options.tappId || readLastSelectedTapp();
+        if (!tappId) {
+            throw new Error("A Tapp is required. Use `tapi studio dev --tapp <id>`. ");
+        }
+        phases.push({ message: "Authenticated with Tapi", detail: auth.uid });
+        phases.push({ message: "Selected Tapp", detail: tappId });
+        phases.push({ message: "Found workspace source", detail: workspaceRoot });
+        await runSdkServiceStart(workspaceRoot);
+        phases.push({ message: "Tapi service is running" });
+        const backendPort = options.backendPort || await findAvailablePort(8767);
+        const uiPort = options.uiPort || await findAvailablePort(5173);
+        const env = {
+            ...process.env,
+            PYTHONUNBUFFERED: "1",
+            TAPI_BASE_URL: options.apiBaseUrl,
+            TAPI_PROJECT_ID: tappId,
+            TAPI_PROJECT_SLUG: tappId,
+            TAPI_STUDIO_API_BASE_URL: options.apiBaseUrl,
+            TAPI_STUDIO_DEV_MODE: "1",
+            TAPI_STUDIO_ID_TOKEN: auth.idToken,
+            TAPI_STUDIO_PORT: String(backendPort),
+            TAPI_STUDIO_UID: auth.uid,
+            TAPI_STUDIO_WORKSPACE_MODE: "1",
+            TAPI_WORKSPACE_ROOT: workspaceRoot,
+            VITE_STUDIO_API_PORT: String(backendPort),
+        };
+        const backend = spawn(python, [
+            "-m", "uvicorn", "tapi_v2.apps.studio_server:create_app", "--factory",
+            "--host", "127.0.0.1", "--port", String(backendPort), "--reload",
+            "--reload-dir", join(workspaceRoot, "tapi_v2", "apps", "studio_server"),
+            "--reload-dir", join(workspaceRoot, "tapi_v2", "plugins", "studio_http_input"),
+            "--reload-dir", join(workspaceRoot, "tapi_v2", "plugins", "servicemap_persistence"),
+        ], { cwd: workspaceRoot, env, stdio: "inherit", windowsHide: true });
+        children.push(backend);
+        phases.push({ message: "Starting workspace Studio backend", detail: `127.0.0.1:${backendPort}` });
+        await waitForHttp(`http://127.0.0.1:${backendPort}/healthz`, backend, "Studio backend");
+        phases.push({ message: "Workspace Studio backend is ready", detail: `127.0.0.1:${backendPort}` });
+        const ui = startVite(uiRoot, uiPort, env);
+        children.push(ui);
+        phases.push({ message: "Starting Vite with hot reload", detail: `127.0.0.1:${uiPort}` });
+        await waitForHttp(`http://127.0.0.1:${uiPort}/`, ui, "Vite UI");
+        phases.push({ message: "Vite UI is ready", detail: `127.0.0.1:${uiPort}` });
+        const launchTrace = Buffer.from(JSON.stringify({ phases }), "utf8").toString("base64url");
+        const url = `http://127.0.0.1:${uiPort}/?project=${encodeURIComponent(tappId)}&tapiDevLaunch=${launchTrace}`;
+        if (options.openBrowser)
+            openUrl(url);
+        console.log(`Opened Tapi Studio development workspace: ${url}`);
+        console.log("Watching React and Python source. Press Ctrl+C to stop development Studio.");
+        const stop = () => {
+            if (stopping)
+                return;
+            stopping = true;
+            for (const child of children)
+                terminateProcessTree(child);
+        };
+        process.once("SIGINT", stop);
+        process.once("SIGTERM", stop);
+        await new Promise((resolvePromise, rejectPromise) => {
+            const handleExit = (label, code, signal) => {
+                if (stopping) {
+                    resolvePromise();
+                    return;
+                }
+                stop();
+                rejectPromise(new Error(`${label} stopped unexpectedly (${signal || code || "unknown"}).`));
+            };
+            backend.once("exit", (code, signal) => handleExit("Studio backend", code, signal));
+            ui.once("exit", (code, signal) => handleExit("Vite UI", code, signal));
+        });
+        return 0;
+    }
+    catch (error) {
+        stopping = true;
+        for (const child of children)
+            terminateProcessTree(child);
+        console.error(error instanceof Error ? error.message : String(error));
+        return 1;
+    }
+}
+function parseDevOptions(args) {
+    const options = {
+        apiBaseUrl: process.env.TAPI_STUDIO_API_BASE_URL || process.env.TAPI_BASE_URL || DEFAULT_API_BASE_URL,
+        openBrowser: true,
+        tappId: process.env.TAPI_PROJECT_ID || "",
+    };
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--tapp")
+            options.tappId = requireValue(args, ++index, arg);
+        else if (arg.startsWith("--tapp="))
+            options.tappId = arg.slice("--tapp=".length);
+        else if (arg === "--api-base-url" || arg === "--server")
+            options.apiBaseUrl = requireValue(args, ++index, arg);
+        else if (arg.startsWith("--api-base-url="))
+            options.apiBaseUrl = arg.slice("--api-base-url=".length);
+        else if (arg.startsWith("--server="))
+            options.apiBaseUrl = arg.slice("--server=".length);
+        else if (arg === "--workspace")
+            options.workspaceRoot = resolve(requireValue(args, ++index, arg));
+        else if (arg.startsWith("--workspace="))
+            options.workspaceRoot = resolve(arg.slice("--workspace=".length));
+        else if (arg === "--backend-port")
+            options.backendPort = parsePort(requireValue(args, ++index, arg));
+        else if (arg.startsWith("--backend-port="))
+            options.backendPort = parsePort(arg.slice("--backend-port=".length));
+        else if (arg === "--ui-port")
+            options.uiPort = parsePort(requireValue(args, ++index, arg));
+        else if (arg.startsWith("--ui-port="))
+            options.uiPort = parsePort(arg.slice("--ui-port=".length));
+        else if (arg === "--no-open")
+            options.openBrowser = false;
+        else
+            throw new Error(`Unknown Studio development option: ${arg}`);
+    }
+    options.tappId = options.tappId.trim();
+    options.apiBaseUrl = options.apiBaseUrl.trim().replace(/\/+$/, "");
+    return options;
+}
+function requireValue(args, index, option) {
+    const value = String(args[index] || "").trim();
+    if (!value)
+        throw new Error(`${option} requires a value.`);
+    return value;
+}
+function parsePort(value) {
+    const port = Number(value);
+    if (!Number.isInteger(port) || port < 1 || port > 65535)
+        throw new Error(`Invalid port: ${value}`);
+    return port;
+}
+function findWorkspaceRoot(start) {
+    let current = resolve(start);
+    for (;;) {
+        const marker = join(current, "tapi_v2", "plugins", "studio_ui_output", "shell", "react", "package.json");
+        if (existsSync(marker))
+            return current;
+        const parent = dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    throw new Error("Tapi Studio source workspace was not found. Run from the repository or pass `--workspace <path>`. ");
+}
+function findWorkspacePython(workspaceRoot) {
+    const candidates = process.platform === "win32"
+        ? [join(workspaceRoot, ".venv-win", "Scripts", "python.exe"), join(workspaceRoot, ".venv", "Scripts", "python.exe")]
+        : [join(workspaceRoot, ".venv", "bin", "python")];
+    const python = candidates.find(candidate => existsSync(candidate));
+    if (!python)
+        throw new Error("Workspace Python environment was not found.");
+    return python;
+}
+function tapiDataDir() {
+    if (process.platform === "win32") {
+        return join(process.env.LOCALAPPDATA || join(process.env.USERPROFILE || homedir(), "AppData", "Local"), "Tapi");
+    }
+    return join(process.env.XDG_DATA_HOME || join(homedir(), ".local", "share"), "tapi");
+}
+async function refreshAuthRecord() {
+    const path = join(tapiDataDir(), "auth.json");
+    if (!existsSync(path))
+        throw new Error("Tapi sign-in is required. Run `tapi login`, then retry.");
+    const cached = JSON.parse(readFileSync(path, "utf8"));
+    const refreshToken = String(cached.refresh_token || "").trim();
+    if (!refreshToken)
+        throw new Error("Tapi sign-in is required. Run `tapi login`, then retry.");
+    const response = await fetch(`https://securetoken.googleapis.com/v1/token?key=${process.env.TAPI_FIREBASE_API_KEY || DEFAULT_FIREBASE_API_KEY}`, {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        body: `grant_type=refresh_token&refresh_token=${encodeURIComponent(refreshToken)}`,
+    });
+    const body = await response.json();
+    const auth = {
+        idToken: String(body.id_token || "").trim(),
+        refreshToken: String(body.refresh_token || "").trim(),
+        uid: String(body.user_id || "").trim(),
+    };
+    if (!response.ok || !auth.idToken || !auth.refreshToken || !auth.uid) {
+        throw new Error("Tapi authentication expired. Run `tapi login`, then retry.");
+    }
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, `${JSON.stringify({ uid: auth.uid, refresh_token: auth.refreshToken, id_token: auth.idToken }, null, 2)}\n`, "utf8");
+    return auth;
+}
+function readLastSelectedTapp() {
+    const path = join(tapiDataDir(), "studio-selection.json");
+    if (!existsSync(path))
+        return "";
+    try {
+        const record = JSON.parse(readFileSync(path, "utf8"));
+        return String(record.lastTappId || "").trim();
+    }
+    catch {
+        return "";
+    }
+}
+async function runSdkServiceStart(workspaceRoot) {
+    const cliPath = process.argv[1];
+    if (!cliPath)
+        return;
+    await new Promise((resolvePromise, rejectPromise) => {
+        const child = spawn(process.execPath, [cliPath, "service", "start"], {
+            cwd: workspaceRoot,
+            env: process.env,
+            stdio: "inherit",
+            windowsHide: true,
+        });
+        child.once("error", rejectPromise);
+        child.once("exit", code => code === 0 ? resolvePromise() : rejectPromise(new Error(`Unable to start Tapi service (exit ${code}).`)));
+    });
+}
+function startVite(uiRoot, port, env) {
+    if (process.platform === "win32") {
+        return spawn(process.env.ComSpec || "cmd.exe", ["/d", "/s", "/c", `npm.cmd run dev -- --host 127.0.0.1 --port ${port} --strictPort`], {
+            cwd: uiRoot,
+            env,
+            stdio: "inherit",
+            windowsHide: true,
+        });
+    }
+    return spawn("npm", ["run", "dev", "--", "--host", "127.0.0.1", "--port", String(port), "--strictPort"], {
+        cwd: uiRoot,
+        env,
+        stdio: "inherit",
+    });
+}
+async function findAvailablePort(start) {
+    for (let port = start; port < start + 100; port += 1) {
+        const available = await new Promise(resolvePromise => {
+            const server = createServer();
+            server.unref();
+            server.once("error", () => resolvePromise(false));
+            server.listen(port, "127.0.0.1", () => server.close(() => resolvePromise(true)));
+        });
+        if (available)
+            return port;
+    }
+    throw new Error(`No available local port found from ${start}.`);
+}
+async function waitForHttp(url, child, label) {
+    const deadline = Date.now() + READY_TIMEOUT_MS;
+    let lastError = "";
+    while (Date.now() < deadline) {
+        if (child.exitCode !== null)
+            throw new Error(`${label} exited before becoming ready (exit ${child.exitCode}).`);
+        try {
+            const response = await fetch(url, { signal: AbortSignal.timeout(2_000) });
+            if (response.ok)
+                return;
+            lastError = `HTTP ${response.status}`;
+        }
+        catch (error) {
+            lastError = error instanceof Error ? error.message : String(error);
+        }
+        await new Promise(resolvePromise => setTimeout(resolvePromise, 250));
+    }
+    throw new Error(`${label} did not become ready within ${READY_TIMEOUT_MS} ms${lastError ? `: ${lastError}` : ""}`);
+}
+function openUrl(url) {
+    const child = process.platform === "win32"
+        ? spawn("rundll32.exe", ["url.dll,FileProtocolHandler", url], { detached: true, stdio: "ignore", windowsHide: true })
+        : spawn(process.platform === "darwin" ? "open" : "xdg-open", [url], { detached: true, stdio: "ignore" });
+    child.unref();
+}
+function terminateProcessTree(child) {
+    if (!child.pid || child.exitCode !== null)
+        return;
+    if (process.platform === "win32") {
+        spawn("taskkill.exe", ["/pid", String(child.pid), "/t", "/f"], { detached: true, stdio: "ignore", windowsHide: true }).unref();
+    }
+    else {
+        child.kill("SIGTERM");
+    }
+}
+function printStudioDevHelp() {
+    console.log(`Tapi Studio development mode
+
+Usage:
+  tapi studio dev --tapp <tapp> [options]
+
+Options:
+  --workspace <path>    Tapi source workspace (defaults to current repository)
+  --tapp <id>           Tapp/project context (defaults to last Studio selection)
+  --api-base-url <url>  Tapi API base URL
+  --backend-port <port> Preferred source backend port
+  --ui-port <port>      Preferred Vite port
+  --no-open             Do not open the browser
+`);
+}

package/dist/workspace.d.ts

@@ -1,5 +1,3 @@
-export declare const TAPI_WORKSPACE_DIR = ".tapi";
-export declare const TAPI_WORKSPACE_CONFIG = "project.json";
 export interface TapiServicesConfig {
     catalog?: string;
     typescript?: string;

package/dist/workspace.js

@@ -1,98 +1,17 @@
-import { existsSync, readFileSync } from "node:fs";
-import { mkdir, writeFile } from "node:fs/promises";
-import { dirname, join, resolve } from "node:path";
-export const TAPI_WORKSPACE_DIR = ".tapi";
-export const TAPI_WORKSPACE_CONFIG = "project.json";
-const RETIRED_SERVICE_HELPER_CONFIG_KEY = "gener" + "ated";
 export function findWorkspaceConfigPath(startDir = process.cwd()) {
-    let current = resolve(startDir);
-    while (true) {
-        const candidate = join(current, TAPI_WORKSPACE_DIR, TAPI_WORKSPACE_CONFIG);
-        if (existsSync(candidate)) {
-            return candidate;
-        }
-        const parent = dirname(current);
-        if (parent === current) {
-            return undefined;
-        }
-        current = parent;
-    }
+    void startDir;
+    return undefined;
 }
 export function loadWorkspace(startDir = process.cwd()) {
-    const configPath = findWorkspaceConfigPath(startDir);
-    if (!configPath) {
-        return undefined;
-    }
-    const config = readWorkspaceConfig(configPath);
-    const root = dirname(dirname(configPath));
-    return {
-        root,
-        configPath,
-        config,
-        projectId: config.projectId,
-        projectSlug: config.projectSlug,
-        apiBaseUrl: config.apiBaseUrl,
-    };
+    void startDir;
+    return undefined;
 }
 export function readWorkspaceConfig(configPath) {
-    let parsed;
-    try {
-        parsed = JSON.parse(readFileSync(configPath, "utf8"));
-    }
-    catch (error) {
-        throw new Error(`Could not read Tapi workspace config at ${configPath}: ${formatError(error)}`);
-    }
-    if (!isRecord(parsed)) {
-        throw new Error(`Tapi workspace config at ${configPath} must be a JSON object.`);
-    }
-    const version = parsed.version;
-    if (version !== 1) {
-        throw new Error(`Tapi workspace config at ${configPath} has unsupported version '${String(version)}'.`);
-    }
-    const projectId = normalizeProjectValue(parsed.projectId, "projectId");
-    const projectSlug = optionalProjectValue(parsed.projectSlug, "projectSlug");
-    const apiBaseUrl = typeof parsed.apiBaseUrl === "string" && parsed.apiBaseUrl.trim() ? parsed.apiBaseUrl.trim() : undefined;
-    const services = isRecord(parsed.services) ? { ...parsed.services } : undefined;
-    if (Object.prototype.hasOwnProperty.call(parsed, RETIRED_SERVICE_HELPER_CONFIG_KEY)) {
-        throw new Error(`Tapi workspace config at ${configPath} uses retired service helper config. Remove '${RETIRED_SERVICE_HELPER_CONFIG_KEY}' and use 'services' instead.`);
-    }
-    const config = { ...parsed };
-    return {
-        ...config,
-        version: 1,
-        projectId,
-        ...(projectSlug ? { projectSlug } : {}),
-        ...(apiBaseUrl ? { apiBaseUrl } : {}),
-        ...(services ? { services } : {}),
-    };
+    throw new Error(`Tapi workspace configs are retired and are no longer read: ${configPath}`);
 }
 export async function writeWorkspaceConfig(options) {
-    const root = resolve(options.root ?? process.cwd());
-    const projectId = normalizeProjectValue(options.projectId, "projectId");
-    const projectSlug = optionalProjectValue(options.projectSlug, "projectSlug") ?? projectId;
-    const configPath = join(root, TAPI_WORKSPACE_DIR, TAPI_WORKSPACE_CONFIG);
-    if (!options.force && existsSync(configPath)) {
-        throw new Error(`Tapi workspace config already exists at ${configPath}. Use --force to overwrite.`);
-    }
-    const config = {
-        version: 1,
-        projectId,
-        projectSlug,
-        ...(options.apiBaseUrl ? { apiBaseUrl: options.apiBaseUrl } : {}),
-        services: {
-            catalog: ".tapi/services/catalog.json",
-        },
-    };
-    await mkdir(dirname(configPath), { recursive: true });
-    await writeFile(configPath, `${JSON.stringify(config, null, 2)}\n`, "utf8");
-    return {
-        root,
-        configPath,
-        config,
-        projectId,
-        projectSlug,
-        apiBaseUrl: config.apiBaseUrl,
-    };
+    void options;
+    throw new Error("tapi init/link are retired. Use `tapi tapp create`, `tapi login`, and `tapi studio <tapp>`.");
 }
 export function normalizeProjectValue(value, fieldName = "project") {
     if (typeof value !== "string") {
@@ -107,15 +26,3 @@ export function normalizeProjectValue(value, fieldName = "project") {
     }
     return project;
 }
-function optionalProjectValue(value, fieldName) {
-    if (value === undefined || value === null || value === "") {
-        return undefined;
-    }
-    return normalizeProjectValue(value, fieldName);
-}
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function formatError(error) {
-    return error instanceof Error ? error.message : String(error);
-}

package/package.json

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