@tapi-dev/sdk 0.1.33 → 0.1.36

package/dist/cli.js

@@ -3,7 +3,7 @@ import { spawn } from "node:child_process";
 import { createServer } from "node:http";
 import { createServer as createNetServer } from "node:net";
 import { createHash, randomUUID } from "node:crypto";
-import { createReadStream, createWriteStream, existsSync, readFileSync, readdirSync } from "node:fs";
+import { createReadStream, createWriteStream, existsSync, readFileSync, readdirSync, realpathSync } from "node:fs";
 import { mkdir, readFile, readdir, rename, rm, stat, statfs, unlink, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { basename, dirname, join, resolve } from "node:path";
@@ -21,7 +21,7 @@ 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;
+export const PORTABLE_STUDIO_SERVER_READY_TIMEOUT_MS = 120_000;
 const PORTABLE_STUDIO_SERVER_READY_INTERVAL_MS = 250;
 const DOWNLOAD_STALL_TIMEOUT_MS = 30_000;
 const DOWNLOAD_PROGRESS_LOG_BYTES = 50 * 1024 * 1024;
@@ -33,6 +33,10 @@ const WINDOWS_SERVICE_COMMAND_TIMEOUT_MS = 30_000;
 const MANAGED_RELEASE_MARKER = ".tapi-managed-release";
 const MIN_EXTRACTION_REQUIRED_BYTES = 1024 * 1024 * 1024;
 const EXTRACTION_REQUIRED_MULTIPLIER = 3;
+const RETIRED_TRIGGER_TARGET_FIELD = "api" + "Request";
+const RUNTIME_OWNER_FIELDS = ["owner"];
+const RETIRED_RUNTIME_OWNER_ALIAS_FIELDS = ["runtimeOwner", "runtime_owner"];
+const SERVICE_RUN_RUNTIME_OWNER = "service_run";
 class StudioInstallApprovalError extends Error {
     code;
     status;
@@ -144,22 +148,77 @@ export async function runCli(argv = process.argv.slice(2)) {
         }
         return runServiceCommand(subcommand, rest);
     }
-    if (command === "apis") {
-        if (!subcommand || subcommand === "help" || subcommand === "--help" || subcommand === "-h" || hasHelpFlag(rest)) {
-            printApisHelp();
+    if (command === "services") {
+        if (!subcommand || subcommand === "help" || subcommand === "--help" || subcommand === "-h") {
+            printServicesHelp();
+            return 0;
+        }
+        if (hasHelpFlag(rest)) {
+            printServicesHelp();
             return 0;
         }
         if (subcommand === "describe") {
-            return describeApiOperation(rest);
+            return describeServiceOperation(rest);
         }
         if (subcommand === "sync") {
-            return syncApiCatalog(rest);
+            return syncServiceCatalog(rest);
+        }
+        console.error(`Unknown service-run command: ${subcommand}`);
+        printServicesHelp();
+        return 1;
+    }
+    if (command === "tapp") {
+        if (!subcommand || subcommand === "help" || subcommand === "--help" || subcommand === "-h" || hasHelpFlag(rest)) {
+            printTappHelp();
+            return 0;
+        }
+        if (subcommand === "create") {
+            return createTapp(rest);
+        }
+        if (subcommand === "service") {
+            const serviceCommand = rest[0] || "";
+            if (serviceCommand === "add") {
+                return addTappService(rest.slice(1));
+            }
+        }
+        if (subcommand === "queue") {
+            const queueCommand = rest[0] || "";
+            if (queueCommand === "add") {
+                return addTappQueue(rest.slice(1));
+            }
+        }
+        console.error(`Unknown Tapp command: ${[subcommand, ...rest].filter(Boolean).join(" ")}`);
+        printTappHelp();
+        return 1;
+    }
+    if (command === "queue") {
+        if (!subcommand || subcommand === "help" || subcommand === "--help" || subcommand === "-h" || hasHelpFlag(rest)) {
+            printQueueHelp();
+            return 0;
+        }
+        if (subcommand === "create") {
+            return createQueue(rest);
+        }
+        console.error(`Unknown queue command: ${subcommand}`);
+        printQueueHelp();
+        return 1;
+    }
+    if (command === "runner") {
+        if (!subcommand || subcommand === "help" || subcommand === "--help" || subcommand === "-h" || hasHelpFlag(rest)) {
+            printRunnerHelp();
+            return 0;
         }
-        if (subcommand === "generate") {
-            return generateApiClient(rest);
+        if (subcommand === "setup") {
+            return runRunnerSetup(rest);
         }
-        console.error(`Unknown apis command: ${subcommand}`);
-        printApisHelp();
+        if (subcommand === "slot") {
+            const slotCommand = rest[0] || "";
+            if (slotCommand === "set") {
+                return setRunnerSlot(rest.slice(1));
+            }
+        }
+        console.error(`Unknown runner command: ${[subcommand, ...rest].filter(Boolean).join(" ")}`);
+        printRunnerHelp();
         return 1;
     }
     if (command === "triggers") {
@@ -168,7 +227,7 @@ export async function runCli(argv = process.argv.slice(2)) {
             return 0;
         }
         if (subcommand === "sync") {
-            return syncApiTriggers(rest);
+            return syncServiceTriggers(rest);
         }
         console.error(`Unknown triggers command: ${subcommand}`);
         printTriggersHelp();
@@ -306,73 +365,597 @@ export function parseStudioOptions(args) {
             raw.installDir = resolve(requireOptionValue(args, ++index, "--install-dir"));
             continue;
         }
-        if (arg.startsWith("--install-dir=")) {
-            raw.installDir = resolve(arg.slice("--install-dir=".length));
+        if (arg.startsWith("--install-dir=")) {
+            raw.installDir = resolve(arg.slice("--install-dir=".length));
+            continue;
+        }
+        if (arg === "--exe") {
+            raw.exePath = resolve(requireOptionValue(args, ++index, "--exe"));
+            continue;
+        }
+        if (arg.startsWith("--exe=")) {
+            raw.exePath = resolve(arg.slice("--exe=".length));
+            continue;
+        }
+        if (arg === "--download-only") {
+            raw.downloadOnly = true;
+            continue;
+        }
+        if (arg === "--silent") {
+            raw.silent = true;
+            continue;
+        }
+        if (arg === "--help" || arg === "-h") {
+            continue;
+        }
+        throw new Error(`Unknown option: ${arg}`);
+    }
+    const workspace = skipWorkspace ? undefined : loadWorkspace(workspaceSearchRoot ?? process.cwd());
+    const channel = raw.channel ?? parseChannel(envString("TAPI_STUDIO_CHANNEL") ?? DEFAULT_CHANNEL);
+    const apiBaseUrl = normalizeHttpUrl(raw.apiBaseUrl
+        ?? envString("TAPI_STUDIO_API_BASE_URL")
+        ?? envString("TAPI_BASE_URL")
+        ?? envString("TAPI_STUDIO_SERVER_URL")
+        ?? workspace?.apiBaseUrl
+        ?? DEFAULT_STUDIO_API_BASE_URL, "Studio API base URL");
+    const downloadsBaseUrl = normalizeHttpUrl(envString("TAPI_DOWNLOADS_BASE_URL") ?? DEFAULT_DOWNLOADS_BASE_URL, "TAPI_DOWNLOADS_BASE_URL");
+    const explicitManifestUrl = raw.manifestUrlOverride ?? envString("TAPI_STUDIO_MANIFEST_URL");
+    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 projectSlug = raw.projectSlug ?? envString("TAPI_PROJECT_SLUG") ?? workspace?.projectSlug;
+    const envInstallToken = envString("TAPI_STUDIO_INSTALL_TOKEN");
+    const installToken = raw.installToken ?? envInstallToken;
+    return {
+        channel,
+        apiBaseUrl,
+        manifestUrl,
+        manifestUrlOverride: explicitManifestUrl ? normalizeHttpUrl(explicitManifestUrl, "Studio manifest URL") : undefined,
+        cacheDir: raw.cacheDir ?? getDefaultStudioCacheDir(),
+        installDir: raw.installDir ?? resolve(envString("TAPI_STUDIO_INSTALL_DIR") ?? getDefaultPortableStudioServerReleasesDir()),
+        downloadOnly: raw.downloadOnly ?? false,
+        silent: raw.silent ?? false,
+        exePath: raw.exePath ?? envString("TAPI_STUDIO_EXE"),
+        installToken,
+        installTokenSource: raw.installToken ? "option" : installToken ? "env" : undefined,
+        workspace,
+        workspaceRoot: workspace?.root,
+        projectId,
+        projectSlug,
+        workspaceMode: Boolean(projectId || workspace),
+    };
+}
+function parseServiceOptions(args) {
+    let operation = "";
+    const workspace = loadWorkspace();
+    let apiBaseUrl = envString("TAPI_BASE_URL") || workspace?.apiBaseUrl || DEFAULT_STUDIO_API_BASE_URL;
+    let apiKey = envString("TAPI_API_KEY") || "";
+    let projectId = envString("TAPI_PROJECT_ID") || workspace?.projectId || "";
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (!arg)
+            continue;
+        if (arg === "--api-base-url" || arg === "--server") {
+            apiBaseUrl = requireOptionValue(args, ++index, arg);
+            continue;
+        }
+        if (arg.startsWith("--api-base-url=")) {
+            apiBaseUrl = arg.slice("--api-base-url=".length);
+            continue;
+        }
+        if (arg.startsWith("--server=")) {
+            apiBaseUrl = arg.slice("--server=".length);
+            continue;
+        }
+        if (arg === "--api-key") {
+            apiKey = requireOptionValue(args, ++index, "--api-key");
+            continue;
+        }
+        if (arg.startsWith("--api-key=")) {
+            apiKey = arg.slice("--api-key=".length);
+            continue;
+        }
+        if (arg === "--project") {
+            projectId = normalizeProjectValue(requireOptionValue(args, ++index, "--project"), "project");
+            continue;
+        }
+        if (arg.startsWith("--project=")) {
+            projectId = normalizeProjectValue(arg.slice("--project=".length), "project");
+            continue;
+        }
+        if (arg.startsWith("--")) {
+            throw new Error(`Unknown services option: ${arg}`);
+        }
+        if (!operation) {
+            operation = arg;
+            continue;
+        }
+        throw new Error(`Unexpected services argument: ${arg}`);
+    }
+    if (!operation) {
+        throw new Error("services describe requires a service run like schwab.place_order.");
+    }
+    if (!apiKey) {
+        throw new Error("services describe requires --api-key or TAPI_API_KEY.");
+    }
+    if (!projectId) {
+        throw new Error("services describe requires --project, TAPI_PROJECT_ID, or .tapi/project.json.");
+    }
+    return {
+        operation,
+        options: {
+            apiBaseUrl: normalizeHttpUrl(apiBaseUrl, "Tapi API base URL"),
+            apiKey,
+            projectId,
+        },
+    };
+}
+async function describeServiceOperation(args) {
+    try {
+        const { operation, options } = parseServiceOptions(args);
+        const client = new TapiClient({
+            baseUrl: options.apiBaseUrl,
+            apiKey: options.apiKey,
+            tappId: options.projectId,
+            projectId: options.projectId,
+        });
+        const description = await withCliSpinner(`Fetching Tapi service-run contract for ${operation}`, () => client.services.describe(operation));
+        console.log(JSON.stringify(description, null, 2));
+        return 0;
+    }
+    catch (error) {
+        console.error(formatError(error));
+        return 1;
+    }
+}
+function parseApiWorkspaceOptions(args) {
+    const workspace = loadWorkspace();
+    let apiBaseUrl = envString("TAPI_BASE_URL") || workspace?.apiBaseUrl || DEFAULT_STUDIO_API_BASE_URL;
+    let apiKey = envString("TAPI_API_KEY") || "";
+    let projectId = envString("TAPI_PROJECT_ID") || workspace?.projectId || "";
+    let catalogPath = workspace?.config.services?.catalog || ".tapi/services/catalog.json";
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (!arg)
+            continue;
+        if (arg === "--api-base-url" || arg === "--server") {
+            apiBaseUrl = requireOptionValue(args, ++index, arg);
+            continue;
+        }
+        if (arg.startsWith("--api-base-url=")) {
+            apiBaseUrl = arg.slice("--api-base-url=".length);
+            continue;
+        }
+        if (arg.startsWith("--server=")) {
+            apiBaseUrl = arg.slice("--server=".length);
+            continue;
+        }
+        if (arg === "--api-key") {
+            apiKey = requireOptionValue(args, ++index, "--api-key");
+            continue;
+        }
+        if (arg.startsWith("--api-key=")) {
+            apiKey = arg.slice("--api-key=".length);
+            continue;
+        }
+        if (arg === "--project") {
+            projectId = normalizeProjectValue(requireOptionValue(args, ++index, "--project"), "project");
+            continue;
+        }
+        if (arg.startsWith("--project=")) {
+            projectId = normalizeProjectValue(arg.slice("--project=".length), "project");
+            continue;
+        }
+        if (arg === "--catalog") {
+            catalogPath = requireOptionValue(args, ++index, "--catalog");
+            continue;
+        }
+        if (arg.startsWith("--catalog=")) {
+            catalogPath = arg.slice("--catalog=".length);
+            continue;
+        }
+        throw new Error(`Unknown services option: ${arg}`);
+    }
+    if (!apiKey) {
+        throw new Error("services command requires --api-key or TAPI_API_KEY.");
+    }
+    if (!projectId) {
+        throw new Error("services command requires --project, TAPI_PROJECT_ID, or .tapi/project.json.");
+    }
+    const root = workspace?.root || process.cwd();
+    return {
+        apiBaseUrl: normalizeHttpUrl(apiBaseUrl, "Tapi API base URL"),
+        apiKey,
+        projectId,
+        catalogPath: resolve(root, catalogPath),
+    };
+}
+async function syncServiceCatalog(args) {
+    try {
+        const options = parseApiWorkspaceOptions(args);
+        const catalog = await withCliSpinner("Fetching Tapi service-run catalog", () => fetchApiCatalog(options));
+        await writeJsonFile(options.catalogPath, catalog);
+        console.log(`Synced Tapi service-run catalog: ${options.catalogPath}`);
+        return 0;
+    }
+    catch (error) {
+        console.error(formatError(error));
+        return 1;
+    }
+}
+function parseTappServiceAddOptions(args) {
+    const workspace = loadWorkspace();
+    let apiBaseUrl = envString("TAPI_BASE_URL") || workspace?.apiBaseUrl || DEFAULT_STUDIO_API_BASE_URL;
+    let apiKey = envString("TAPI_API_KEY") || "";
+    let tappId = "";
+    let serviceCall = "";
+    let serviceMapId = "";
+    let entry = "";
+    let expectedRevision = "";
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (!arg)
+            continue;
+        if (arg === "--api-base-url" || arg === "--server") {
+            apiBaseUrl = requireOptionValue(args, ++index, arg);
+            continue;
+        }
+        if (arg.startsWith("--api-base-url=")) {
+            apiBaseUrl = arg.slice("--api-base-url=".length);
+            continue;
+        }
+        if (arg.startsWith("--server=")) {
+            apiBaseUrl = arg.slice("--server=".length);
+            continue;
+        }
+        if (arg === "--api-key") {
+            apiKey = requireOptionValue(args, ++index, "--api-key");
+            continue;
+        }
+        if (arg.startsWith("--api-key=")) {
+            apiKey = arg.slice("--api-key=".length);
+            continue;
+        }
+        if (arg === "--service-map") {
+            serviceMapId = requireOptionValue(args, ++index, "--service-map");
+            continue;
+        }
+        if (arg.startsWith("--service-map=")) {
+            serviceMapId = arg.slice("--service-map=".length);
+            continue;
+        }
+        if (arg === "--entry") {
+            entry = requireOptionValue(args, ++index, "--entry");
+            continue;
+        }
+        if (arg.startsWith("--entry=")) {
+            entry = arg.slice("--entry=".length);
+            continue;
+        }
+        if (arg === "--expected-revision") {
+            expectedRevision = requireOptionValue(args, ++index, "--expected-revision");
+            continue;
+        }
+        if (arg.startsWith("--expected-revision=")) {
+            expectedRevision = arg.slice("--expected-revision=".length);
+            continue;
+        }
+        if (arg.startsWith("--")) {
+            throw new Error(`Unknown tapp service add option: ${arg}`);
+        }
+        if (!tappId) {
+            tappId = normalizeProjectValue(arg, "tapp");
+            continue;
+        }
+        if (!serviceCall) {
+            serviceCall = arg.trim();
+            continue;
+        }
+        throw new Error(`Unexpected tapp service add argument: ${arg}`);
+    }
+    if (!apiKey) {
+        throw new Error("tapp service add requires --api-key or TAPI_API_KEY.");
+    }
+    if (!tappId) {
+        throw new Error("tapp service add requires a Tapp id.");
+    }
+    if (!serviceCall || !serviceCall.includes(".")) {
+        throw new Error("tapp service add requires a service call like schwab.place_order.");
+    }
+    if (!serviceMapId) {
+        throw new Error("tapp service add requires --service-map.");
+    }
+    if (!entry) {
+        throw new Error("tapp service add requires --entry.");
+    }
+    return {
+        apiBaseUrl: normalizeHttpUrl(apiBaseUrl, "Tapi API base URL"),
+        apiKey,
+        tappId,
+        serviceCall,
+        serviceMapId,
+        entry,
+        expectedRevision,
+    };
+}
+function parseTappCreateOptions(args) {
+    const workspace = loadWorkspace();
+    let apiBaseUrl = envString("TAPI_BASE_URL") || workspace?.apiBaseUrl || DEFAULT_STUDIO_API_BASE_URL;
+    let apiKey = envString("TAPI_API_KEY") || "";
+    let tappId = envString("TAPI_PROJECT_ID") || workspace?.projectId || "";
+    let name = "";
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (!arg)
+            continue;
+        if (arg === "--api-base-url" || arg === "--server") {
+            apiBaseUrl = requireOptionValue(args, ++index, arg);
+            continue;
+        }
+        if (arg.startsWith("--api-base-url=")) {
+            apiBaseUrl = arg.slice("--api-base-url=".length);
+            continue;
+        }
+        if (arg.startsWith("--server=")) {
+            apiBaseUrl = arg.slice("--server=".length);
+            continue;
+        }
+        if (arg === "--api-key") {
+            apiKey = requireOptionValue(args, ++index, "--api-key");
+            continue;
+        }
+        if (arg.startsWith("--api-key=")) {
+            apiKey = arg.slice("--api-key=".length);
+            continue;
+        }
+        if (arg === "--tapp-id" || arg === "--project") {
+            tappId = normalizeProjectValue(requireOptionValue(args, ++index, arg), "tapp");
+            continue;
+        }
+        if (arg.startsWith("--tapp-id=")) {
+            tappId = normalizeProjectValue(arg.slice("--tapp-id=".length), "tapp");
+            continue;
+        }
+        if (arg.startsWith("--project=")) {
+            tappId = normalizeProjectValue(arg.slice("--project=".length), "tapp");
+            continue;
+        }
+        if (arg === "--name") {
+            name = requireOptionValue(args, ++index, "--name").trim();
+            continue;
+        }
+        if (arg.startsWith("--name=")) {
+            name = arg.slice("--name=".length).trim();
+            continue;
+        }
+        if (arg.startsWith("--")) {
+            throw new Error(`Unknown tapp create option: ${arg}`);
+        }
+        if (!name) {
+            name = arg.trim();
+            if (!tappId) {
+                tappId = normalizeProjectValue(name, "tapp");
+            }
+            continue;
+        }
+        throw new Error(`Unexpected tapp create argument: ${arg}`);
+    }
+    if (!apiKey) {
+        throw new Error("tapp create requires --api-key or TAPI_API_KEY.");
+    }
+    if (!tappId) {
+        throw new Error("tapp create requires a Tapp id or name.");
+    }
+    if (!name) {
+        name = tappId;
+    }
+    return {
+        apiBaseUrl: normalizeHttpUrl(apiBaseUrl, "Tapi API base URL"),
+        apiKey,
+        tappId,
+        name,
+    };
+}
+async function createTapp(args) {
+    try {
+        const options = parseTappCreateOptions(args);
+        const tapp = await withCliSpinner(`Creating Tapi Tapp ${options.tappId}`, () => postTappCreate(options));
+        console.log(JSON.stringify(tapp, null, 2));
+        return 0;
+    }
+    catch (error) {
+        console.error(formatError(error));
+        return 1;
+    }
+}
+async function postTappCreate(options, fetchImpl = fetch) {
+    const response = await fetchImpl(`${options.apiBaseUrl.replace(/\/+$/, "")}/api/sdk/v1/tapps`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "X-API-Key": options.apiKey,
+            "X-Tapi-Project": options.tappId,
+        },
+        body: JSON.stringify({
+            tappId: options.tappId,
+            name: options.name,
+        }),
+    });
+    const body = await readJsonBody(response);
+    if (!response.ok) {
+        const detail = body?.detail ?? body?.error ?? body ?? `HTTP ${response.status}`;
+        throw new Error(typeof detail === "string" ? detail : JSON.stringify(detail));
+    }
+    return body ?? {};
+}
+async function addTappService(args) {
+    try {
+        const options = parseTappServiceAddOptions(args);
+        const operation = await withCliSpinner(`Adding Tapi service ${options.serviceCall} to ${options.tappId}`, () => postTappServiceAdd(options));
+        console.log(JSON.stringify(operation, null, 2));
+        return 0;
+    }
+    catch (error) {
+        console.error(formatError(error));
+        return 1;
+    }
+}
+async function postTappServiceAdd(options) {
+    const response = await fetch(`${options.apiBaseUrl.replace(/\/+$/, "")}/api/sdk/v1/tapps/${encodeURIComponent(options.tappId)}/services/${encodeURIComponent(options.serviceCall)}`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "X-API-Key": options.apiKey,
+            "X-Tapi-Project": options.tappId,
+        },
+        body: JSON.stringify({
+            serviceMapId: options.serviceMapId,
+            entry: options.entry,
+            ...(options.expectedRevision ? { expectedRevision: options.expectedRevision } : {}),
+        }),
+    });
+    const body = await readJsonBody(response);
+    if (!response.ok) {
+        const detail = body?.detail ?? body?.error ?? body ?? `HTTP ${response.status}`;
+        throw new Error(typeof detail === "string" ? detail : JSON.stringify(detail));
+    }
+    return body ?? {};
+}
+function parseQueueCreateOptions(args) {
+    const workspace = loadWorkspace();
+    let apiBaseUrl = envString("TAPI_BASE_URL") || workspace?.apiBaseUrl || DEFAULT_STUDIO_API_BASE_URL;
+    let apiKey = envString("TAPI_API_KEY") || "";
+    let projectId = envString("TAPI_PROJECT_ID") || workspace?.projectId || "";
+    let displayName = "";
+    let maxSlots = 8;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (!arg)
+            continue;
+        if (arg === "--api-base-url" || arg === "--server") {
+            apiBaseUrl = requireOptionValue(args, ++index, arg);
+            continue;
+        }
+        if (arg.startsWith("--api-base-url=")) {
+            apiBaseUrl = arg.slice("--api-base-url=".length);
+            continue;
+        }
+        if (arg.startsWith("--server=")) {
+            apiBaseUrl = arg.slice("--server=".length);
+            continue;
+        }
+        if (arg === "--api-key") {
+            apiKey = requireOptionValue(args, ++index, "--api-key");
+            continue;
+        }
+        if (arg.startsWith("--api-key=")) {
+            apiKey = arg.slice("--api-key=".length);
+            continue;
+        }
+        if (arg === "--project") {
+            projectId = normalizeProjectValue(requireOptionValue(args, ++index, "--project"), "project");
+            continue;
+        }
+        if (arg.startsWith("--project=")) {
+            projectId = normalizeProjectValue(arg.slice("--project=".length), "project");
+            continue;
+        }
+        if (arg === "--max-slots") {
+            maxSlots = parsePositiveInteger(requireOptionValue(args, ++index, "--max-slots"), "--max-slots");
+            continue;
+        }
+        if (arg.startsWith("--max-slots=")) {
+            maxSlots = parsePositiveInteger(arg.slice("--max-slots=".length), "--max-slots");
+            continue;
+        }
+        if (arg.startsWith("--")) {
+            throw new Error(`Unknown queue create option: ${arg}`);
+        }
+        if (!displayName) {
+            displayName = arg.trim();
+            continue;
+        }
+        throw new Error(`Unexpected queue create argument: ${arg}`);
+    }
+    if (!apiKey) {
+        throw new Error("queue create requires --api-key or TAPI_API_KEY.");
+    }
+    return {
+        apiBaseUrl: normalizeHttpUrl(apiBaseUrl, "Tapi API base URL"),
+        apiKey,
+        projectId,
+        displayName,
+        maxSlots,
+    };
+}
+function parseTappQueueAddOptions(args) {
+    const workspace = loadWorkspace();
+    let apiBaseUrl = envString("TAPI_BASE_URL") || workspace?.apiBaseUrl || DEFAULT_STUDIO_API_BASE_URL;
+    let apiKey = envString("TAPI_API_KEY") || "";
+    let tappId = "";
+    let queueId = "";
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (!arg)
+            continue;
+        if (arg === "--api-base-url" || arg === "--server") {
+            apiBaseUrl = requireOptionValue(args, ++index, arg);
+            continue;
+        }
+        if (arg.startsWith("--api-base-url=")) {
+            apiBaseUrl = arg.slice("--api-base-url=".length);
             continue;
         }
-        if (arg === "--exe") {
-            raw.exePath = resolve(requireOptionValue(args, ++index, "--exe"));
+        if (arg.startsWith("--server=")) {
+            apiBaseUrl = arg.slice("--server=".length);
             continue;
         }
-        if (arg.startsWith("--exe=")) {
-            raw.exePath = resolve(arg.slice("--exe=".length));
+        if (arg === "--api-key") {
+            apiKey = requireOptionValue(args, ++index, "--api-key");
             continue;
         }
-        if (arg === "--download-only") {
-            raw.downloadOnly = true;
+        if (arg.startsWith("--api-key=")) {
+            apiKey = arg.slice("--api-key=".length);
             continue;
         }
-        if (arg === "--silent") {
-            raw.silent = true;
+        if (arg.startsWith("--")) {
+            throw new Error(`Unknown tapp queue add option: ${arg}`);
+        }
+        if (!tappId) {
+            tappId = normalizeProjectValue(arg, "tapp");
             continue;
         }
-        if (arg === "--help" || arg === "-h") {
+        if (!queueId) {
+            queueId = arg.trim();
             continue;
         }
-        throw new Error(`Unknown option: ${arg}`);
+        throw new Error(`Unexpected tapp queue add argument: ${arg}`);
+    }
+    if (!apiKey) {
+        throw new Error("tapp queue add requires --api-key or TAPI_API_KEY.");
+    }
+    if (!tappId) {
+        throw new Error("tapp queue add requires a Tapp id.");
+    }
+    if (!queueId) {
+        throw new Error("tapp queue add requires a queue id.");
     }
-    const workspace = skipWorkspace ? undefined : loadWorkspace(workspaceSearchRoot ?? process.cwd());
-    const channel = raw.channel ?? parseChannel(envString("TAPI_STUDIO_CHANNEL") ?? DEFAULT_CHANNEL);
-    const apiBaseUrl = normalizeHttpUrl(raw.apiBaseUrl
-        ?? envString("TAPI_STUDIO_API_BASE_URL")
-        ?? envString("TAPI_BASE_URL")
-        ?? envString("TAPI_STUDIO_SERVER_URL")
-        ?? workspace?.apiBaseUrl
-        ?? DEFAULT_STUDIO_API_BASE_URL, "Studio API base URL");
-    const downloadsBaseUrl = normalizeHttpUrl(envString("TAPI_DOWNLOADS_BASE_URL") ?? DEFAULT_DOWNLOADS_BASE_URL, "TAPI_DOWNLOADS_BASE_URL");
-    const explicitManifestUrl = raw.manifestUrlOverride ?? envString("TAPI_STUDIO_MANIFEST_URL");
-    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 projectSlug = raw.projectSlug ?? envString("TAPI_PROJECT_SLUG") ?? workspace?.projectSlug;
-    const envInstallToken = envString("TAPI_STUDIO_INSTALL_TOKEN");
-    const installToken = raw.installToken ?? envInstallToken;
     return {
-        channel,
-        apiBaseUrl,
-        manifestUrl,
-        manifestUrlOverride: explicitManifestUrl ? normalizeHttpUrl(explicitManifestUrl, "Studio manifest URL") : undefined,
-        cacheDir: raw.cacheDir ?? getDefaultStudioCacheDir(),
-        installDir: raw.installDir ?? resolve(envString("TAPI_STUDIO_INSTALL_DIR") ?? getDefaultPortableStudioServerReleasesDir()),
-        downloadOnly: raw.downloadOnly ?? false,
-        silent: raw.silent ?? false,
-        exePath: raw.exePath ?? envString("TAPI_STUDIO_EXE"),
-        installToken,
-        installTokenSource: raw.installToken ? "option" : installToken ? "env" : undefined,
-        workspace,
-        workspaceRoot: workspace?.root,
-        projectId,
-        projectSlug,
-        workspaceMode: Boolean(projectId || workspace),
+        apiBaseUrl: normalizeHttpUrl(apiBaseUrl, "Tapi API base URL"),
+        apiKey,
+        tappId,
+        queueId,
     };
 }
-function parseApiOptions(args) {
-    let operation = "";
+function parseRunnerSlotSetOptions(args) {
     const workspace = loadWorkspace();
     let apiBaseUrl = envString("TAPI_BASE_URL") || workspace?.apiBaseUrl || DEFAULT_STUDIO_API_BASE_URL;
     let apiKey = envString("TAPI_API_KEY") || "";
     let projectId = envString("TAPI_PROJECT_ID") || workspace?.projectId || "";
+    let runnerId = "";
+    let slotIndex = 0;
+    let queueId = "";
     for (let index = 0; index < args.length; index += 1) {
         const arg = args[index];
         if (!arg)
@@ -406,42 +989,51 @@ function parseApiOptions(args) {
             continue;
         }
         if (arg.startsWith("--")) {
-            throw new Error(`Unknown apis option: ${arg}`);
+            throw new Error(`Unknown runner slot set option: ${arg}`);
         }
-        if (!operation) {
-            operation = arg;
+        if (!runnerId) {
+            runnerId = arg.trim();
             continue;
         }
-        throw new Error(`Unexpected apis argument: ${arg}`);
-    }
-    if (!operation) {
-        throw new Error("apis describe requires an operation like schwab.place_order.");
+        if (!slotIndex) {
+            slotIndex = parsePositiveInteger(arg.trim(), "slot index");
+            continue;
+        }
+        if (!queueId) {
+            queueId = arg.trim();
+            continue;
+        }
+        throw new Error(`Unexpected runner slot set argument: ${arg}`);
     }
     if (!apiKey) {
-        throw new Error("apis describe requires --api-key or TAPI_API_KEY.");
+        throw new Error("runner slot set requires --api-key or TAPI_API_KEY.");
     }
     if (!projectId) {
-        throw new Error("apis describe requires --project, TAPI_PROJECT_ID, or .tapi/project.json.");
+        throw new Error("runner slot set requires --project or TAPI_PROJECT_ID.");
+    }
+    if (!runnerId) {
+        throw new Error("runner slot set requires a runner id.");
+    }
+    if (!slotIndex) {
+        throw new Error("runner slot set requires a slot index.");
+    }
+    if (!queueId) {
+        throw new Error("runner slot set requires a queue id.");
     }
     return {
-        operation,
-        options: {
-            apiBaseUrl: normalizeHttpUrl(apiBaseUrl, "Tapi API base URL"),
-            apiKey,
-            projectId,
-        },
+        apiBaseUrl: normalizeHttpUrl(apiBaseUrl, "Tapi API base URL"),
+        apiKey,
+        projectId,
+        runnerId,
+        slotIndex,
+        queueId,
     };
 }
-async function describeApiOperation(args) {
+async function createQueue(args) {
     try {
-        const { operation, options } = parseApiOptions(args);
-        const client = new TapiClient({
-            baseUrl: options.apiBaseUrl,
-            apiKey: options.apiKey,
-            projectId: options.projectId,
-        });
-        const description = await withCliSpinner(`Fetching Tapi API description for ${operation}`, () => client.services.describe(operation));
-        console.log(JSON.stringify(description, null, 2));
+        const options = parseQueueCreateOptions(args);
+        const queue = await withCliSpinner(`Creating Tapi queue`, () => postQueueCreate(options));
+        console.log(JSON.stringify(queue, null, 2));
         return 0;
     }
     catch (error) {
@@ -449,13 +1041,95 @@ async function describeApiOperation(args) {
         return 1;
     }
 }
-function parseApiWorkspaceOptions(args) {
+async function addTappQueue(args) {
+    try {
+        const options = parseTappQueueAddOptions(args);
+        const result = await withCliSpinner(`Attaching Tapi queue ${options.queueId} to ${options.tappId}`, () => postTappQueueAdd(options));
+        console.log(JSON.stringify(result, null, 2));
+        return 0;
+    }
+    catch (error) {
+        console.error(formatError(error));
+        return 1;
+    }
+}
+async function setRunnerSlot(args) {
+    try {
+        const options = parseRunnerSlotSetOptions(args);
+        const result = await withCliSpinner(`Assigning runner slot ${options.runnerId}/${options.slotIndex} to queue ${options.queueId}`, () => putRunnerSlot(options));
+        console.log(JSON.stringify(result, null, 2));
+        return 0;
+    }
+    catch (error) {
+        console.error(formatError(error));
+        return 1;
+    }
+}
+async function postQueueCreate(options) {
+    const headers = {
+        "Content-Type": "application/json",
+        "X-API-Key": options.apiKey,
+    };
+    if (options.projectId) {
+        headers["X-Tapi-Project"] = options.projectId;
+    }
+    const response = await fetch(`${options.apiBaseUrl.replace(/\/+$/, "")}/api/sdk/v1/queues`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+            ...(options.displayName ? { displayName: options.displayName } : {}),
+            maxSlots: options.maxSlots,
+        }),
+    });
+    const body = await readJsonBody(response);
+    if (!response.ok) {
+        const detail = body?.detail ?? body?.error ?? body ?? `HTTP ${response.status}`;
+        throw new Error(typeof detail === "string" ? detail : JSON.stringify(detail));
+    }
+    return body ?? {};
+}
+async function postTappQueueAdd(options) {
+    const response = await fetch(`${options.apiBaseUrl.replace(/\/+$/, "")}/api/sdk/v1/tapps/${encodeURIComponent(options.tappId)}/queues`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "X-API-Key": options.apiKey,
+            "X-Tapi-Project": options.tappId,
+        },
+        body: JSON.stringify({ queueId: options.queueId }),
+    });
+    const body = await readJsonBody(response);
+    if (!response.ok) {
+        const detail = body?.detail ?? body?.error ?? body ?? `HTTP ${response.status}`;
+        throw new Error(typeof detail === "string" ? detail : JSON.stringify(detail));
+    }
+    return body ?? {};
+}
+async function putRunnerSlot(options) {
+    const response = await fetch(`${options.apiBaseUrl.replace(/\/+$/, "")}/api/sdk/v1/runners/${encodeURIComponent(options.runnerId)}/slots/${encodeURIComponent(String(options.slotIndex))}`, {
+        method: "PUT",
+        headers: {
+            "Content-Type": "application/json",
+            "X-API-Key": options.apiKey,
+            "X-Tapi-Project": options.projectId,
+        },
+        body: JSON.stringify({ queueId: options.queueId }),
+    });
+    const body = await readJsonBody(response);
+    if (!response.ok) {
+        const detail = body?.detail ?? body?.error ?? body ?? `HTTP ${response.status}`;
+        throw new Error(typeof detail === "string" ? detail : JSON.stringify(detail));
+    }
+    return body ?? {};
+}
+export function parseRunnerSetupOptions(args) {
     const workspace = loadWorkspace();
     let apiBaseUrl = envString("TAPI_BASE_URL") || workspace?.apiBaseUrl || DEFAULT_STUDIO_API_BASE_URL;
     let apiKey = envString("TAPI_API_KEY") || "";
     let projectId = envString("TAPI_PROJECT_ID") || workspace?.projectId || "";
-    let catalogPath = workspace?.config.generated?.catalog || ".tapi/generated/catalog.json";
-    let typescriptPath = workspace?.config.generated?.typescript || "src/tapi.generated.ts";
+    let runnerId = envString("TAPI_RUNNER_ID") || "";
+    let port = Number(envString("TAPI_RUNNER_SETUP_PORT") || "17687");
+    let openBrowser = true;
     for (let index = 0; index < args.length; index += 1) {
         const arg = args[index];
         if (!arg)
@@ -488,45 +1162,67 @@ function parseApiWorkspaceOptions(args) {
             projectId = normalizeProjectValue(arg.slice("--project=".length), "project");
             continue;
         }
-        if (arg === "--catalog") {
-            catalogPath = requireOptionValue(args, ++index, "--catalog");
+        if (arg === "--runner-id") {
+            runnerId = requireOptionValue(args, ++index, "--runner-id").trim();
             continue;
         }
-        if (arg.startsWith("--catalog=")) {
-            catalogPath = arg.slice("--catalog=".length);
+        if (arg.startsWith("--runner-id=")) {
+            runnerId = arg.slice("--runner-id=".length).trim();
+            continue;
+        }
+        if (arg === "--port") {
+            port = parseNonNegativeInteger(requireOptionValue(args, ++index, "--port"), "--port");
             continue;
         }
-        if (arg === "--out") {
-            typescriptPath = requireOptionValue(args, ++index, "--out");
+        if (arg.startsWith("--port=")) {
+            port = parseNonNegativeInteger(arg.slice("--port=".length), "--port");
             continue;
         }
-        if (arg.startsWith("--out=")) {
-            typescriptPath = arg.slice("--out=".length);
+        if (arg === "--no-open") {
+            openBrowser = false;
             continue;
         }
-        throw new Error(`Unknown apis option: ${arg}`);
+        if (arg.startsWith("--")) {
+            throw new Error(`Unknown runner setup option: ${arg}`);
+        }
+        if (!runnerId) {
+            runnerId = arg.trim();
+            continue;
+        }
+        throw new Error(`Unexpected runner setup argument: ${arg}`);
     }
     if (!apiKey) {
-        throw new Error("apis command requires --api-key or TAPI_API_KEY.");
+        throw new Error("runner setup requires --api-key or TAPI_API_KEY.");
     }
     if (!projectId) {
-        throw new Error("apis command requires --project, TAPI_PROJECT_ID, or .tapi/project.json.");
+        throw new Error("runner setup requires --project or TAPI_PROJECT_ID.");
+    }
+    if (!runnerId) {
+        throw new Error("runner setup requires --runner-id or TAPI_RUNNER_ID.");
+    }
+    if (!Number.isInteger(port) || port < 0) {
+        throw new Error("--port must be a non-negative integer.");
     }
-    const root = workspace?.root || process.cwd();
     return {
         apiBaseUrl: normalizeHttpUrl(apiBaseUrl, "Tapi API base URL"),
         apiKey,
         projectId,
-        catalogPath: resolve(root, catalogPath),
-        typescriptPath: resolve(root, typescriptPath),
+        runnerId,
+        port,
+        openBrowser,
     };
 }
-async function syncApiCatalog(args) {
+async function runRunnerSetup(args) {
     try {
-        const options = parseApiWorkspaceOptions(args);
-        const catalog = await withCliSpinner("Fetching Tapi API catalog", () => fetchApiCatalog(options));
-        await writeJsonFile(options.catalogPath, catalog);
-        console.log(`Synced Tapi API catalog: ${options.catalogPath}`);
+        const options = parseRunnerSetupOptions(args);
+        const handle = await startRunnerSetupServer(options);
+        if (options.openBrowser) {
+            openUrlInBrowser(handle.url);
+        }
+        console.log(`Tapi runner setup: ${handle.url}`);
+        console.log("Press Ctrl+C to stop the setup server.");
+        await waitForProcessSignal();
+        await handle.close();
         return 0;
     }
     catch (error) {
@@ -534,19 +1230,216 @@ async function syncApiCatalog(args) {
         return 1;
     }
 }
-async function generateApiClient(args) {
+export async function startRunnerSetupServer(options, fetchImpl = fetch) {
+    const server = createServer((request, response) => {
+        void handleRunnerSetupRequest(request, response, options, fetchImpl);
+    });
+    await listenOnLocalhost(server, options.port);
+    const address = server.address();
+    const port = typeof address === "object" && address ? address.port : options.port;
+    return {
+        url: `http://127.0.0.1:${port}/`,
+        port,
+        close: () => closeServer(server),
+    };
+}
+export async function executeRunnerSetupAction(options, action, fetchImpl = fetch) {
+    let queueId = String(action.queueId || "").trim();
+    const maxSlots = coercePositiveInteger(action.maxSlots, 8, "maxSlots");
+    const slotStart = coercePositiveInteger(action.slotStart, 1, "slotStart");
+    const slotCount = coercePositiveInteger(action.slotCount, 1, "slotCount");
+    let queue = {};
+    if (!queueId) {
+        queue = await sdkJsonRequest(fetchImpl, `${options.apiBaseUrl.replace(/\/+$/, "")}/api/sdk/v1/queues`, {
+            method: "POST",
+            headers: sdkJsonHeaders(options.apiKey, options.projectId),
+            body: JSON.stringify({
+                displayName: String(action.displayName || `${options.projectId} queue`).trim(),
+                maxSlots,
+            }),
+        });
+        queueId = String(queue.queueId || queue.queue_id || "").trim();
+    }
+    if (!queueId) {
+        throw new Error("Runner setup needs an existing queue id or a created queue response with queueId.");
+    }
+    const attachment = await sdkJsonRequest(fetchImpl, `${options.apiBaseUrl.replace(/\/+$/, "")}/api/sdk/v1/tapps/${encodeURIComponent(options.projectId)}/queues`, {
+        method: "POST",
+        headers: sdkJsonHeaders(options.apiKey, options.projectId),
+        body: JSON.stringify({ queueId }),
+    });
+    const slots = [];
+    for (let offset = 0; offset < slotCount; offset += 1) {
+        const slotIndex = slotStart + offset;
+        slots.push(await sdkJsonRequest(fetchImpl, `${options.apiBaseUrl.replace(/\/+$/, "")}/api/sdk/v1/runners/${encodeURIComponent(options.runnerId)}/slots/${encodeURIComponent(String(slotIndex))}`, {
+            method: "PUT",
+            headers: sdkJsonHeaders(options.apiKey, options.projectId),
+            body: JSON.stringify({ queueId }),
+        }));
+    }
+    return {
+        queueId,
+        queue: queueId && !Object.keys(queue).length ? { queueId } : queue,
+        attachment,
+        slots,
+    };
+}
+async function handleRunnerSetupRequest(request, response, options, fetchImpl) {
     try {
-        const options = parseApiWorkspaceOptions(args);
-        const catalog = await withCliSpinner("Fetching Tapi API catalog", () => fetchApiCatalog(options));
-        await writeJsonFile(options.catalogPath, catalog);
-        await writeTextFile(options.typescriptPath, renderGeneratedApiClient(catalog));
-        console.log(`Generated Tapi API client: ${options.typescriptPath}`);
-        return 0;
+        const url = new URL(request.url || "/", "http://127.0.0.1");
+        if (request.method === "GET" && url.pathname === "/") {
+            sendText(response, 200, runnerSetupHtml(options), "text/html; charset=utf-8");
+            return;
+        }
+        if (request.method === "GET" && url.pathname === "/api/status") {
+            sendJson(response, 200, {
+                apiBaseUrl: options.apiBaseUrl,
+                projectId: options.projectId,
+                runnerId: options.runnerId,
+            });
+            return;
+        }
+        if (request.method === "POST" && url.pathname === "/api/setup") {
+            const body = await readRequestJson(request);
+            const result = await executeRunnerSetupAction(options, body, fetchImpl);
+            sendJson(response, 200, result);
+            return;
+        }
+        sendJson(response, 404, { error: "not found" });
     }
     catch (error) {
-        console.error(formatError(error));
-        return 1;
+        sendJson(response, 400, { error: formatError(error) });
+    }
+}
+function runnerSetupHtml(options) {
+    const displayName = `${options.projectId} queue`;
+    return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width,initial-scale=1">
+<title>Tapi Runner Setup</title>
+<style>
+:root { color-scheme: light dark; --bg: #f7f7f5; --panel: #ffffff; --text: #1d2329; --muted: #62707c; --line: #d6dde2; --accent: #176b4d; --accent-2: #0f5ca8; --danger: #ad2e24; }
+@media (prefers-color-scheme: dark) { :root { --bg: #111418; --panel: #181d22; --text: #eef3f6; --muted: #a6b1bb; --line: #303a43; --accent: #59b88c; --accent-2: #6da8e8; --danger: #ee786e; } }
+* { box-sizing: border-box; }
+body { margin: 0; font: 14px/1.45 system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; color: var(--text); background: var(--bg); }
+main { max-width: 920px; margin: 0 auto; padding: 28px 18px 36px; }
+h1 { margin: 0 0 18px; font-size: 28px; font-weight: 650; letter-spacing: 0; }
+h2 { margin: 0 0 12px; font-size: 16px; font-weight: 650; letter-spacing: 0; }
+.grid { display: grid; grid-template-columns: minmax(0, 1fr) minmax(260px, 320px); gap: 18px; align-items: start; }
+.panel, .summary { background: var(--panel); border: 1px solid var(--line); border-radius: 8px; padding: 18px; }
+.row { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: 12px; }
+label { display: grid; gap: 6px; margin: 0 0 12px; color: var(--muted); font-size: 12px; font-weight: 600; text-transform: uppercase; }
+input { width: 100%; min-width: 0; border: 1px solid var(--line); border-radius: 6px; padding: 10px 11px; color: var(--text); background: transparent; font: inherit; }
+button { border: 0; border-radius: 6px; padding: 11px 14px; color: white; background: var(--accent); font: inherit; font-weight: 650; cursor: pointer; }
+button:disabled { opacity: .55; cursor: progress; }
+code { word-break: break-all; }
+.summary dl { display: grid; grid-template-columns: 88px minmax(0, 1fr); gap: 8px 10px; margin: 0; }
+.summary dt { color: var(--muted); font-weight: 650; }
+.summary dd { margin: 0; min-width: 0; }
+.result { margin-top: 14px; min-height: 120px; border: 1px solid var(--line); border-radius: 8px; padding: 12px; overflow: auto; background: rgba(0,0,0,.035); white-space: pre-wrap; }
+.error { color: var(--danger); }
+.ok { color: var(--accent-2); }
+@media (max-width: 720px) { .grid, .row { grid-template-columns: 1fr; } main { padding: 20px 14px 28px; } h1 { font-size: 24px; } }
+</style>
+</head>
+<body>
+<main>
+<h1>Tapi Runner Setup</h1>
+<div class="grid">
+<section class="panel">
+<h2>Queue And Slots</h2>
+<form id="setup-form">
+<label>Existing Queue ID<input id="queueId" name="queueId" autocomplete="off" placeholder="queue_abc123"></label>
+<label>New Queue Name<input id="displayName" name="displayName" value="${escapeHtml(displayName)}" autocomplete="off"></label>
+<div class="row">
+<label>Queue Slot Limit<input id="maxSlots" name="maxSlots" type="number" min="1" step="1" value="8"></label>
+<label>First Runner Slot<input id="slotStart" name="slotStart" type="number" min="1" step="1" value="1"></label>
+</div>
+<label>Runner Slot Count<input id="slotCount" name="slotCount" type="number" min="1" step="1" value="1"></label>
+<button id="submit" type="submit">Apply Setup</button>
+</form>
+<pre id="result" class="result" aria-live="polite"></pre>
+</section>
+<aside class="summary">
+<h2>Target</h2>
+<dl>
+<dt>Server</dt><dd><code>${escapeHtml(options.apiBaseUrl)}</code></dd>
+<dt>Tapp</dt><dd><code>${escapeHtml(options.projectId)}</code></dd>
+<dt>Runner</dt><dd><code>${escapeHtml(options.runnerId)}</code></dd>
+</dl>
+</aside>
+</div>
+</main>
+<script>
+const form = document.getElementById("setup-form");
+const button = document.getElementById("submit");
+const result = document.getElementById("result");
+form.addEventListener("submit", async (event) => {
+  event.preventDefault();
+  button.disabled = true;
+  result.className = "result";
+  result.textContent = "Applying setup...";
+  const body = Object.fromEntries(new FormData(form).entries());
+  body.maxSlots = Number(body.maxSlots || 8);
+  body.slotStart = Number(body.slotStart || 1);
+  body.slotCount = Number(body.slotCount || 1);
+  try {
+    const response = await fetch("/api/setup", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+    });
+    const payload = await response.json();
+    if (!response.ok) throw new Error(payload.error || JSON.stringify(payload));
+    result.className = "result ok";
+    result.textContent = JSON.stringify(payload, null, 2);
+    document.getElementById("queueId").value = payload.queueId || body.queueId || "";
+  } catch (error) {
+    result.className = "result error";
+    result.textContent = error instanceof Error ? error.message : String(error);
+  } finally {
+    button.disabled = false;
+  }
+});
+</script>
+</body>
+</html>`;
+}
+async function sdkJsonRequest(fetchImpl, url, init) {
+    const response = await fetchImpl(url, init);
+    const body = await readJsonBody(response);
+    if (!response.ok) {
+        const detail = body?.detail ?? body?.error ?? body ?? `HTTP ${response.status}`;
+        throw new Error(typeof detail === "string" ? detail : JSON.stringify(detail));
+    }
+    return body ?? {};
+}
+function sdkJsonHeaders(apiKey, projectId) {
+    return {
+        "Content-Type": "application/json",
+        "X-API-Key": apiKey,
+        "X-Tapi-Project": projectId,
+    };
+}
+function coercePositiveInteger(value, fallback, label) {
+    const text = value === undefined || value === null || value === "" ? String(fallback) : String(value);
+    return parsePositiveInteger(text, label);
+}
+function parsePositiveInteger(value, label) {
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed < 1) {
+        throw new Error(`${label} must be a positive integer.`);
+    }
+    return parsed;
+}
+function parseNonNegativeInteger(value, label) {
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed < 0) {
+        throw new Error(`${label} must be a non-negative integer.`);
     }
+    return parsed;
 }
 function parseTriggerSyncOptions(args) {
     const workspace = loadWorkspace();
@@ -610,24 +1503,25 @@ function parseTriggerSyncOptions(args) {
         configPath: configPath ? resolve(root, configPath) : defaultTriggerConfigPath(root),
     };
 }
-async function syncApiTriggers(args) {
+async function syncServiceTriggers(args) {
     try {
         const options = parseTriggerSyncOptions(args);
-        const triggers = await readApiTriggerConfig(options.configPath);
+        const triggers = await readServiceTriggerConfig(options.configPath);
         if (triggers.length === 0) {
-            throw new Error(`No Tapi API triggers found in ${options.configPath}.`);
+            throw new Error(`No Tapi service triggers found in ${options.configPath}.`);
         }
         const client = new TapiClient({
             baseUrl: options.apiBaseUrl,
             apiKey: options.apiKey,
+            tappId: options.projectId,
             projectId: options.projectId,
         });
-        await withCliSpinner(`Syncing ${triggers.length} Tapi API trigger(s)`, async () => {
+        await withCliSpinner(`Syncing ${triggers.length} Tapi service trigger(s)`, async () => {
             for (const trigger of triggers) {
                 await client.triggers.create(trigger);
             }
         });
-        console.log(`Synced ${triggers.length} Tapi API trigger(s) from ${options.configPath}.`);
+        console.log(`Synced ${triggers.length} Tapi service trigger(s) from ${options.configPath}.`);
         return 0;
     }
     catch (error) {
@@ -770,6 +1664,7 @@ async function fetchDevSessions(options) {
     const client = new TapiClient({
         baseUrl: options.apiBaseUrl,
         apiKey: options.apiKey,
+        tappId: options.projectId,
         projectId: options.projectId,
     });
     return await withCliSpinner("Fetching Tapi dev sessions", () => client.sessions.list({ site: options.site }));
@@ -897,7 +1792,6 @@ async function openDevSessionInStudio(session, options) {
 function studioSessionLaunchParams(session) {
     const params = new URLSearchParams();
     params.set("runId", session.id);
-    params.set("apiRunId", session.id);
     if (session.sitemap)
         params.set("sitemap", session.sitemap);
     if (session.runtimeSessionId)
@@ -908,7 +1802,6 @@ function studioSessionSelectIntent(session) {
     return {
         sessionId: session.id,
         runId: session.id,
-        apiRunId: session.id,
         ...(session.sitemap ? { sitemap: session.sitemap } : {}),
         ...(session.runtimeSessionId ? { runtimeSessionId: session.runtimeSessionId } : {}),
         source: "cli",
@@ -961,12 +1854,12 @@ function renderDevSessions(sessions, selectedId = "") {
             const openable = session.openable ? "*" : " ";
             const id = truncateText(session.id || "", 18).padEnd(18, " ");
             const status = truncateText(String(session.status || ""), 24).padEnd(24, " ");
-            const apiName = session.apiName && session.requestKey
-                ? `${session.apiName}.${session.requestKey}`
-                : session.apiName || session.requestKey || "unknown";
+            const serviceRun = session.serviceRun || (session.serviceName && session.serviceKey
+                ? `${session.serviceName}.${session.serviceKey}`
+                : session.serviceName || session.serviceKey || "unknown");
             const state = session.stateLabel ? ` state=${session.stateLabel}` : "";
             const url = session.currentUrl ? ` ${truncateText(session.currentUrl, 60)}` : "";
-            lines.push(`${selected}${openable} ${id} ${status} ${apiName}${state}${url}`);
+            lines.push(`${selected}${openable} ${id} ${status} ${serviceRun}${state}${url}`);
         }
     }
     lines.push("");
@@ -988,7 +1881,7 @@ function defaultTriggerConfigPath(root) {
     }
     return join(root, "tapi.config.json");
 }
-async function readApiTriggerConfig(configPath) {
+async function readServiceTriggerConfig(configPath) {
     if (!existsSync(configPath)) {
         throw new Error(`Tapi trigger config not found at ${configPath}. Create tapi.config.json or pass --config.`);
     }
@@ -1051,24 +1944,31 @@ function normalizeTriggerEntry(entry, index, configPath) {
         throw new Error(`Trigger #${index + 1} in ${configPath} must be an object.`);
     }
     const name = stringField(entry.name, `Trigger #${index + 1} name`);
-    const apiRequest = optionalStringField(entry.apiRequest, "apiRequest") ??
-        optionalStringField(entry.api, "api") ??
-        apiRequestFromParts(entry.apiName, entry.requestKey);
-    if (!apiRequest) {
-        throw new Error(`Trigger '${name}' requires apiRequest, api, or apiName/requestKey.`);
+    if (RETIRED_TRIGGER_TARGET_FIELD in entry) {
+        throw new Error(`Trigger '${name}' uses a retired trigger target field; use serviceRun.`);
+    }
+    const serviceRun = optionalStringField(entry.serviceRun, "serviceRun");
+    if (!serviceRun) {
+        throw new Error(`Trigger '${name}' requires serviceRun.`);
     }
-    if (!apiRequest.includes(".")) {
-        throw new Error(`Trigger '${name}' apiRequest must be formatted as '<apiName>.<requestKey>'.`);
+    if (!serviceRun.includes(".")) {
+        throw new Error(`Trigger '${name}' serviceRun must be formatted as '<serviceName>.<serviceKey>'.`);
+    }
+    if ("runnerId" in entry) {
+        throw new Error(`Trigger '${name}' uses runnerId; use queueId.`);
     }
     const schedule = normalizeTriggerSchedule(entry.schedule, entry.interval, name);
+    const runtime = entry.runtime === undefined ? undefined : recordField(entry.runtime, `Trigger '${name}' runtime`);
+    rejectNonPolicyTriggerRuntimeOwner(runtime, `Trigger '${name}' runtime`);
+    const queueId = stringField(entry.queueId, `Trigger '${name}' queueId`);
     const request = {
         name,
-        apiRequest,
+        serviceRun,
+        queueId,
         ...(entry.enabled === undefined ? {} : { enabled: booleanField(entry.enabled, `Trigger '${name}' enabled`) }),
         ...(schedule ? { schedule } : {}),
         ...(entry.inputs === undefined ? {} : { inputs: recordField(entry.inputs, `Trigger '${name}' inputs`) }),
-        ...(entry.runtime === undefined ? {} : { runtime: recordField(entry.runtime, `Trigger '${name}' runtime`) }),
-        ...(entry.runnerId === undefined ? {} : { runnerId: stringField(entry.runnerId, `Trigger '${name}' runnerId`) }),
+        ...(runtime === undefined ? {} : { runtime }),
         ...(entry.priority === undefined ? {} : { priority: numberField(entry.priority, `Trigger '${name}' priority`) }),
         ...(entry.site === undefined ? {} : { site: stringField(entry.site, `Trigger '${name}' site`) }),
     };
@@ -1151,11 +2051,6 @@ function parseDurationSeconds(value, fieldName) {
     }
     return seconds;
 }
-function apiRequestFromParts(apiName, requestKey) {
-    const api = optionalStringField(apiName, "apiName");
-    const request = optionalStringField(requestKey, "requestKey");
-    return api && request ? `${api}.${request}` : undefined;
-}
 function stringField(value, fieldName) {
     if (typeof value !== "string" || !value.trim()) {
         throw new Error(`${fieldName} must be a non-empty string.`);
@@ -1186,10 +2081,30 @@ function recordField(value, fieldName) {
     }
     return value;
 }
+function rejectNonPolicyTriggerRuntimeOwner(runtime, fieldName) {
+    if (!runtime) {
+        return;
+    }
+    for (const field of RETIRED_RUNTIME_OWNER_ALIAS_FIELDS) {
+        if (field in runtime) {
+            throw new Error(`unsupported service trigger runtime field: ${field}`);
+        }
+    }
+    for (const field of RUNTIME_OWNER_FIELDS) {
+        if (!(field in runtime)) {
+            continue;
+        }
+        const owner = String(runtime[field] ?? "").trim().toLowerCase();
+        if (owner && owner !== SERVICE_RUN_RUNTIME_OWNER) {
+            throw new Error(`${fieldName} owner must be service_run.`);
+        }
+    }
+}
 async function fetchApiCatalog(options) {
     const client = new TapiClient({
         baseUrl: options.apiBaseUrl,
         apiKey: options.apiKey,
+        tappId: options.projectId,
         projectId: options.projectId,
     });
     return client.catalog.get();
@@ -1201,50 +2116,6 @@ async function writeTextFile(path, content) {
     await mkdir(dirname(path), { recursive: true });
     await writeFile(path, content, "utf8");
 }
-function renderGeneratedApiClient(catalog) {
-    const namespaces = new Map();
-    for (const api of catalog.apis || []) {
-        const namespace = safeIdentifier(api.name || "api");
-        for (const request of api.requests || []) {
-            const key = String(request.operation || request.sdkName || request.key || "").trim();
-            if (!key)
-                continue;
-            const operationName = safeIdentifier(key);
-            const operation = `${api.name}.${key}`;
-            const items = namespaces.get(namespace) ?? [];
-            items.push({ key: operation, operationName });
-            namespaces.set(namespace, items);
-        }
-    }
-    const namespaceBlocks = [...namespaces.entries()].map(([namespace, operations]) => {
-        const lines = operations.map(({ key, operationName }) => `    ${operationName}: (inputs: Record<string, unknown> = {}, options: GeneratedRunOptions = {}) => client.services.run(${JSON.stringify(key)}, { ...options, inputs }),`);
-        return `  ${namespace}: {\n${lines.join("\n")}\n  },`;
-    });
-    return `/* Generated by Tapi. Do not edit by hand. */
-import { TapiClient, type TapiClientOptions, type RuntimeRunOptions } from "@tapi-dev/sdk";
-
-export interface GeneratedRunOptions {
-  runtime?: RuntimeRunOptions;
-  priority?: number;
-  runnerId?: string;
-  idempotencyKey?: string;
-  site?: string;
-}
-
-export function createTapiGeneratedClient(options: TapiClientOptions) {
-  const client = new TapiClient(options);
-  return {
-${namespaceBlocks.join("\n")}
-  };
-}
-`;
-}
-function safeIdentifier(value) {
-    const cleaned = String(value || "api")
-        .replace(/[^a-zA-Z0-9_$]+/g, "_")
-        .replace(/^([^a-zA-Z_$])/, "_$1");
-    return cleaned || "api";
-}
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -2444,31 +3315,31 @@ async function stopPortableStudioServerProcesses() {
     if (process.platform !== "win32") {
         return 0;
     }
-    const script = `
-$ErrorActionPreference = 'SilentlyContinue'
-$currentPid = $PID
-$processes = @(Get-Process -ErrorAction SilentlyContinue | Where-Object {
-  $pidValue = [int]$_.Id
-  if ($pidValue -le 0 -or $pidValue -eq $currentPid) {
-    $false
-  } else {
-    $path = ''
-    try { $path = [string]$_.Path } catch {}
-    $name = [string]$_.ProcessName
-    (
-      $name -ieq 'tapi-studio-server' -or
-      $path -match '\\\\Tapi\\\\Studio\\\\server\\\\releases\\\\'
-    )
-  }
-})
-$stopped = 0
-foreach ($process in $processes) {
-  try {
-    Stop-Process -Id ([int]$process.Id) -Force -ErrorAction Stop
-    $stopped += 1
-  } catch {}
-}
-[pscustomobject]@{ stopped = $stopped } | ConvertTo-Json -Compress
+    const script = `
+$ErrorActionPreference = 'SilentlyContinue'
+$currentPid = $PID
+$processes = @(Get-Process -ErrorAction SilentlyContinue | Where-Object {
+  $pidValue = [int]$_.Id
+  if ($pidValue -le 0 -or $pidValue -eq $currentPid) {
+    $false
+  } else {
+    $path = ''
+    try { $path = [string]$_.Path } catch {}
+    $name = [string]$_.ProcessName
+    (
+      $name -ieq 'tapi-studio-server' -or
+      $path -match '\\\\Tapi\\\\Studio\\\\server\\\\releases\\\\'
+    )
+  }
+})
+$stopped = 0
+foreach ($process in $processes) {
+  try {
+    Stop-Process -Id ([int]$process.Id) -Force -ErrorAction Stop
+    $stopped += 1
+  } catch {}
+}
+[pscustomobject]@{ stopped = $stopped } | ConvertTo-Json -Compress
 `;
     try {
         const output = await runProcessCapture("powershell.exe", [
@@ -2992,6 +3863,56 @@ function openBrowser(url) {
     });
     child.unref();
 }
+function openUrlInBrowser(url) {
+    if (process.platform === "win32") {
+        openBrowser(url);
+        return;
+    }
+    const command = process.platform === "darwin" ? "open" : "xdg-open";
+    const child = spawn(command, [url], {
+        detached: true,
+        stdio: "ignore",
+        windowsHide: true,
+    });
+    child.unref();
+}
+async function listenOnLocalhost(server, port) {
+    await new Promise((resolvePromise, rejectPromise) => {
+        const onError = (error) => {
+            server.off("listening", onListening);
+            rejectPromise(error);
+        };
+        const onListening = () => {
+            server.off("error", onError);
+            resolvePromise();
+        };
+        server.once("error", onError);
+        server.once("listening", onListening);
+        server.listen(port, "127.0.0.1");
+    });
+}
+async function closeServer(server) {
+    await new Promise((resolvePromise, rejectPromise) => {
+        server.close((error) => {
+            if (error) {
+                rejectPromise(error);
+                return;
+            }
+            resolvePromise();
+        });
+    });
+}
+async function waitForProcessSignal() {
+    await new Promise((resolvePromise) => {
+        const done = () => {
+            process.off("SIGINT", done);
+            process.off("SIGTERM", done);
+            resolvePromise();
+        };
+        process.once("SIGINT", done);
+        process.once("SIGTERM", done);
+    });
+}
 async function readJsonBody(response) {
     const text = await response.text();
     if (!text.trim()) {
@@ -3004,6 +3925,40 @@ async function readJsonBody(response) {
         return null;
     }
 }
+async function readRequestJson(request) {
+    let body = "";
+    for await (const chunk of request) {
+        body += Buffer.isBuffer(chunk) ? chunk.toString("utf8") : String(chunk);
+        if (Buffer.byteLength(body, "utf8") > 64 * 1024) {
+            throw new Error("request body is too large");
+        }
+    }
+    if (!body.trim()) {
+        return {};
+    }
+    const parsed = JSON.parse(body);
+    if (!isRecord(parsed)) {
+        throw new Error("request body must be a JSON object");
+    }
+    return parsed;
+}
+function sendText(response, status, text, contentType) {
+    response.statusCode = status;
+    response.setHeader("Content-Type", contentType);
+    response.setHeader("Cache-Control", "no-store");
+    response.end(text);
+}
+function sendJson(response, status, payload) {
+    sendText(response, status, JSON.stringify(payload), "application/json; charset=utf-8");
+}
+function escapeHtml(value) {
+    return value
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&#39;");
+}
 function isApprovalTerminalError(error) {
     return error instanceof StudioInstallApprovalError
         && (error.code === "pending_approval" || error.code === "access_pending" || error.code === "access_rejected");
@@ -3558,11 +4513,16 @@ Usage:
   tapi link --project PROJECT
   tapi studio install [--channel pilot] [--api-base-url URL]
   tapi studio
-  tapi studio open
-  tapi studio doctor
-  tapi apis describe <namespace.operation>
-  tapi apis sync
-  tapi apis generate
+  tapi studio open
+  tapi studio doctor
+  tapi tapp create <tapp>
+  tapi queue create [display-name]
+  tapi tapp service add <tapp> <service.call> --service-map ID --entry ENTRY
+  tapi tapp queue add <tapp> <queue-id>
+  tapi runner setup --runner-id RUNNER --project TAPP
+  tapi runner slot set <runner-id> <slot-index> <queue-id>
+  tapi services describe <servicemap.run>
+  tapi services sync
   tapi triggers sync
   tapi sessions
   tapi service status
@@ -3572,18 +4532,75 @@ 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 doctor   Check local SDK and Studio release configuration
-  apis describe   Print a generated website API input/output contract
-  apis sync       Save the published API catalog to .tapi/generated
-  apis generate   Generate a TypeScript runtime wrapper from the catalog
-  triggers sync   Upsert API-call triggers from tapi.config
+  studio          Open Tapi Studio for this repo
+  studio open     Open Tapi Studio for this repo
+  studio doctor   Check local SDK and Studio release configuration
+  tapp create     Create a Tapp
+  queue create    Create a queue for service-run routing
+  tapp service add
+                  Add a ServiceMap-backed service call to a Tapp
+  tapp queue add  Attach a queue to a Tapp
+  runner setup    Open the local runner queue/slot setup UI
+  runner slot set Assign a queue to a runner slot
+  services describe
+                  Print a ServiceMap service-run input/output contract
+  services sync   Save the service-run catalog to .tapi/services
+  triggers sync   Upsert service triggers from tapi.config
   sessions        List dev-mode API sessions and open takeover sessions
   service         Inspect or control the local Tapi Windows service
   doctor          Alias for studio doctor
 `);
 }
+function printTappHelp() {
+    console.log(`Tapi Tapp commands
+
+Usage:
+  tapi tapp create <tapp> [--name NAME] [--api-base-url URL] [--api-key KEY]
+  tapi tapp service add <tapp> <service.call> --service-map ID --entry ENTRY [--api-base-url URL] [--api-key KEY]
+  tapi tapp queue add <tapp> <queue-id> [--api-base-url URL] [--api-key KEY]
+
+Options:
+  --api-base-url <url>     Tapi API base URL
+  --server <url>           Alias for --api-base-url
+  --api-key <key>          Tapi API key; defaults to TAPI_API_KEY
+  --tapp-id <id>           Explicit Tapp id for tapp create
+  --name <name>            Display name for tapp create
+  --service-map <id>       Backing ServiceMap id
+  --entry <entry>          ServiceMap entry URL/name to launch
+  --expected-revision <r>  Optional ServiceMap revision guard
+`);
+}
+function printQueueHelp() {
+    console.log(`Tapi queue commands
+
+Usage:
+  tapi queue create [display-name] [--max-slots N] [--project TAPP] [--api-base-url URL] [--api-key KEY]
+
+Options:
+  --api-base-url <url>  Tapi API base URL
+  --server <url>        Alias for --api-base-url
+  --api-key <key>       Tapi API key; defaults to TAPI_API_KEY
+  --project <id>        Optional project scope for the queue request
+  --max-slots <n>       Maximum runner slots this queue may use
+`);
+}
+function printRunnerHelp() {
+    console.log(`Tapi runner commands
+
+Usage:
+  tapi runner setup --runner-id RUNNER --project TAPP [--port PORT] [--no-open] [--api-base-url URL] [--api-key KEY]
+  tapi runner slot set <runner-id> <slot-index> <queue-id> [--project TAPP] [--api-base-url URL] [--api-key KEY]
+
+Options:
+  --api-base-url <url>  Tapi API base URL
+  --server <url>        Alias for --api-base-url
+  --api-key <key>       Tapi API key; defaults to TAPI_API_KEY
+  --project <id>        Tapi project id; defaults to TAPI_PROJECT_ID or .tapi/project.json
+  --runner-id <id>      Runner id for setup; defaults to TAPI_RUNNER_ID
+  --port <n>            Local setup UI port; defaults to 17687
+  --no-open             Print the setup URL without opening a browser
+`);
+}
 function printSessionsHelp() {
     console.log(`Tapi dev session commands
 
@@ -3602,13 +4619,12 @@ Options:
   --no-interactive       Print the grouped list without the arrow-key picker
 `);
 }
-function printApisHelp() {
-    console.log(`Tapi generated website API commands
+function printServicesHelp() {
+    console.log(`Tapi ServiceMap service-run commands
 
 Usage:
-  tapi apis describe <namespace.operation> [--api-base-url URL] [--api-key KEY] [--project PROJECT]
-  tapi apis sync [--api-base-url URL] [--api-key KEY] [--project PROJECT]
-  tapi apis generate [--api-base-url URL] [--api-key KEY] [--project PROJECT] [--out FILE]
+  tapi services describe <servicemap.run> [--api-base-url URL] [--api-key KEY] [--project PROJECT]
+  tapi services sync [--api-base-url URL] [--api-key KEY] [--project PROJECT]
 
 Options:
   --api-base-url <url>   Tapi API base URL
@@ -3616,11 +4632,10 @@ Options:
   --api-key <key>        Tapi API key; defaults to TAPI_API_KEY
   --project <id>         Tapi project id; defaults to TAPI_PROJECT_ID or .tapi/project.json
   --catalog <path>       Catalog JSON output path
-  --out <path>           Generated TypeScript output path
 `);
 }
 function printTriggersHelp() {
-    console.log(`Tapi API trigger commands
+    console.log(`Tapi service trigger commands
 
 Usage:
   tapi triggers sync [--config FILE] [--api-base-url URL] [--api-key KEY] [--project PROJECT]
@@ -3636,10 +4651,10 @@ Config:
   export default {
     triggers: {
       nightlyBalance: {
-        apiRequest: "schwab.get_balance",
+        serviceRun: "schwab.get_balance",
         interval: "1h",
         inputs: { accountId: "main" },
-        runtime: { profileRef: "perm_default" },
+        runtime: { owner: "service_run", profileRef: "perm_default" },
       },
     },
   };
@@ -3752,7 +4767,15 @@ function serializeError(error) {
 }
 function isCliEntrypoint() {
     const invokedPath = process.argv[1];
-    return Boolean(invokedPath && resolve(invokedPath) === fileURLToPath(import.meta.url));
+    return Boolean(invokedPath && realCliPath(invokedPath) === realCliPath(fileURLToPath(import.meta.url)));
+}
+function realCliPath(path) {
+    try {
+        return realpathSync(path);
+    }
+    catch {
+        return resolve(path);
+    }
 }
 if (isCliEntrypoint()) {
     runCli().then((code) => {