@tapi-dev/sdk 0.1.40 → 0.1.45

package/dist/runner-dev.d.ts

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

package/dist/runner-dev.js

@@ -0,0 +1,270 @@
+import { spawn, execFileSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, watch } from "node:fs";
+import { createServer } from "node:http";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+export async function openRunnerDev(args) {
+    const options = parseOptions(args);
+    if (!options.tapp) {
+        throw new Error("Runner dev mode requires --tapp <tapp>");
+    }
+    const workspace = findWorkspace(options.workspace || process.cwd());
+    const python = findPython(workspace);
+    const safeTapp = safeName(options.tapp);
+    const stateRoot = join(localAppData(), "Tapi", "dev-runners", safeTapp);
+    const leaseFile = join(stateRoot, "worker.json");
+    const statusPort = runnerDevStatusPort(options.tapp);
+    mkdirSync(stateRoot, { recursive: true });
+    let child = null;
+    let watcher = null;
+    let stopping = false;
+    let restarting = false;
+    let restartTimer = null;
+    let outputBuffer = "";
+    const status = {
+        mode: "runner-dev",
+        tappId: options.tapp,
+        state: "starting",
+        detail: "Preparing the source Runner",
+        queueId: "",
+        capacity: options.capacity,
+        pid: 0,
+        updatedAt: new Date().toISOString(),
+        command: `tapi runner dev --tapp ${options.tapp} --capacity ${options.capacity}`,
+    };
+    const setStatus = (patch) => {
+        Object.assign(status, patch, { updatedAt: new Date().toISOString() });
+    };
+    const server = await startStatusServer(statusPort, status);
+    console.log(`[runner-dev] Studio status: http://127.0.0.1:${statusPort}/session`);
+    const handleWorkerOutput = (chunk) => {
+        const text = chunk.toString("utf8");
+        process.stdout.write(text);
+        outputBuffer += text;
+        const lines = outputBuffer.split(/\r?\n/);
+        outputBuffer = lines.pop() || "";
+        for (const line of lines) {
+            if (!line.startsWith("TAPI_DEV_STATUS "))
+                continue;
+            try {
+                const payload = JSON.parse(line.slice("TAPI_DEV_STATUS ".length));
+                setStatus({
+                    state: String(payload.state || status.state),
+                    detail: String(payload.detail || status.detail),
+                    queueId: String(payload.queueId || status.queueId),
+                    capacity: Number(payload.capacity || status.capacity),
+                });
+            }
+            catch {
+                // Worker logs remain useful even if a single status line is malformed.
+            }
+        }
+    };
+    const startWorker = () => {
+        outputBuffer = "";
+        setStatus({
+            state: "configuring",
+            detail: "Creating or restoring the development capacity",
+            pid: 0,
+        });
+        const workerArgs = [
+            "-m", "tapi_v3.runner.dev_mode",
+            "--tapp", options.tapp,
+            "--capacity", String(options.capacity),
+            "--state-root", stateRoot,
+        ];
+        if (options.server)
+            workerArgs.push("--server", options.server);
+        const env = {
+            ...process.env,
+            PYTHONPATH: [workspace, process.env.PYTHONPATH || ""].filter(Boolean).join(";"),
+            PYTHONDONTWRITEBYTECODE: "1",
+            TAPI_CAPACITY_STORE_PATH: join(stateRoot, "capacity-ids.json"),
+            TAPI_CAPACITY_CONFIGURATION_ADDRESS: `\\\\.\\pipe\\tapi-runner-dev-${safeTapp}`,
+            TAPI_CAPACITY_CONFIGURATION_KEY_FILE: join(stateRoot, "worker-control.key"),
+            TAPI_DEV_RUNNER: "1",
+            TAPI_DEV_TAPP: options.tapp,
+        };
+        child = spawn(python, workerArgs, {
+            cwd: workspace,
+            env,
+            stdio: ["ignore", "pipe", "pipe"],
+            windowsHide: true,
+        });
+        setStatus({ pid: child.pid || 0 });
+        child.stdout?.on("data", handleWorkerOutput);
+        child.stderr?.on("data", (chunk) => process.stderr.write(chunk.toString("utf8")));
+        child.on("exit", (code, signal) => {
+            const wasRestart = restarting;
+            child = null;
+            if (stopping)
+                return;
+            if (wasRestart) {
+                restarting = false;
+                startWorker();
+                return;
+            }
+            setStatus({
+                state: "error",
+                detail: `Source Runner exited (${signal || code || "unknown"}); edit a Runner source file to retry`,
+                pid: 0,
+            });
+        });
+    };
+    const restartWorker = () => {
+        if (stopping || restarting)
+            return;
+        restarting = true;
+        setStatus({ state: "reloading", detail: "Runner source changed; restarting the worker subprocess" });
+        if (!child?.pid) {
+            restarting = false;
+            startWorker();
+            return;
+        }
+        stopProcessTree(child.pid);
+    };
+    startWorker();
+    if (options.watch) {
+        watcher = watch(join(workspace, "tapi_v3", "runner"), { recursive: true }, (_event, filename) => {
+            const changed = String(filename || "");
+            if (!changed.endsWith(".py") || changed.includes("__pycache__"))
+                return;
+            if (restartTimer)
+                clearTimeout(restartTimer);
+            restartTimer = setTimeout(restartWorker, 600);
+        });
+        console.log("[runner-dev] Watching tapi_v3/runner for Python changes");
+    }
+    const shutdown = () => {
+        if (stopping)
+            return;
+        stopping = true;
+        watcher?.close();
+        if (restartTimer)
+            clearTimeout(restartTimer);
+        if (child?.pid)
+            stopProcessTree(child.pid);
+        server.close();
+        setStatus({ state: "stopped", detail: "Development Runner stopped", pid: 0 });
+        setTimeout(() => process.exit(0), 50);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    process.stdin.resume();
+    if (existsSync(leaseFile)) {
+        try {
+            const lease = JSON.parse(readFileSync(leaseFile, "utf8"));
+            if (lease.pid)
+                setStatus({ detail: "Replacing the previous development Runner lease" });
+        }
+        catch {
+            // The worker owns and repairs its lease.
+        }
+    }
+}
+function parseOptions(args) {
+    const options = {
+        tapp: "",
+        capacity: 4,
+        workspace: "",
+        server: "",
+        watch: true,
+    };
+    for (let index = 0; index < args.length; index += 1) {
+        const value = args[index];
+        if (value === "--tapp")
+            options.tapp = String(args[++index] || "").trim();
+        else if (value === "--capacity")
+            options.capacity = Math.max(1, Number(args[++index] || 4));
+        else if (value === "--workspace")
+            options.workspace = String(args[++index] || "").trim();
+        else if (value === "--server")
+            options.server = String(args[++index] || "").trim();
+        else if (value === "--no-watch")
+            options.watch = false;
+        else if (value === "--help" || value === "-h") {
+            console.log([
+                "Usage: tapi runner dev --tapp <tapp> [options]",
+                "",
+                "Options:",
+                "  --capacity <count>   Development slots (default: 4)",
+                "  --workspace <path>   Tapi source workspace",
+                "  --server <url>       Railway Runner endpoint override",
+                "  --no-watch           Disable source-triggered worker restarts",
+            ].join("\n"));
+            process.exit(0);
+        }
+        else {
+            throw new Error(`Unknown runner dev option: ${value}`);
+        }
+    }
+    if (!Number.isFinite(options.capacity))
+        options.capacity = 4;
+    options.capacity = Math.min(64, Math.floor(options.capacity));
+    return options;
+}
+function findWorkspace(start) {
+    let current = resolve(start);
+    for (;;) {
+        if (existsSync(join(current, "tapi_v3", "runner", "worker", "main.py")))
+            return current;
+        const parent = resolve(current, "..");
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    throw new Error(`Could not find Tapi source workspace from ${start}; pass --workspace <path>`);
+}
+function findPython(workspace) {
+    const candidates = [
+        join(workspace, ".venv-win", "Scripts", "python.exe"),
+        join(workspace, ".venv", "Scripts", "python.exe"),
+        join(workspace, ".venv", "bin", "python"),
+    ];
+    return candidates.find(existsSync) || "python";
+}
+function localAppData() {
+    return process.env.LOCALAPPDATA || join(homedir(), "AppData", "Local");
+}
+function safeName(value) {
+    return value.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80) || "default";
+}
+function runnerDevStatusPort(tapp) {
+    let hash = 0;
+    for (const character of tapp)
+        hash = ((hash * 31) + character.charCodeAt(0)) >>> 0;
+    return 19000 + (hash % 1000);
+}
+function startStatusServer(port, status) {
+    const server = createServer((request, response) => {
+        response.setHeader("Access-Control-Allow-Origin", "*");
+        response.setHeader("Access-Control-Allow-Methods", "GET, OPTIONS");
+        response.setHeader("Cache-Control", "no-store");
+        if (request.method === "OPTIONS") {
+            response.writeHead(204).end();
+            return;
+        }
+        if (request.url !== "/session") {
+            response.writeHead(404, { "Content-Type": "application/json" }).end(JSON.stringify({ error: "not found" }));
+            return;
+        }
+        response.writeHead(200, { "Content-Type": "application/json" }).end(JSON.stringify(status));
+    });
+    return new Promise((resolvePromise, reject) => {
+        server.once("error", reject);
+        server.listen(port, "127.0.0.1", () => resolvePromise(server));
+    });
+}
+function stopProcessTree(pid) {
+    try {
+        if (process.platform === "win32") {
+            execFileSync("taskkill", ["/PID", String(pid), "/T", "/F"], { stdio: "ignore", windowsHide: true });
+        }
+        else {
+            process.kill(pid, "SIGTERM");
+        }
+    }
+    catch {
+        // The process may already be gone.
+    }
+}

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;