@tapi-dev/sdk 0.1.44 → 0.1.45

package/dist/cli.js

@@ -18,6 +18,7 @@ import pc from "yoctocolors";
 import { TapiClient } from "./index.js";
 import { normalizeProjectValue, writeWorkspaceConfig, } from "./workspace.js";
 import { openStudioDev } from "./studio-dev.js";
+import { openRunnerDev } from "./runner-dev.js";
 const DEFAULT_DOWNLOADS_BASE_URL = "https://d4xaf52nfwiok.cloudfront.net";
 const DEFAULT_STUDIO_API_BASE_URL = "https://determined-motivation-production.up.railway.app";
 const DEFAULT_STUDIO_AUTH_HTML_URL = "https://rsarlong-1f92fd.gitlab.io/auth.html";
@@ -167,6 +168,10 @@ async function authenticateSdkUser() {
 }
 export async function runCli(argv = process.argv.slice(2)) {
     const [command, subcommand, ...rest] = argv;
+    if (command === "runner" && subcommand === "dev") {
+        await openRunnerDev(rest);
+        return 0;
+    }
     if (!command || command === "help" || command === "--help" || command === "-h") {
         printHelp();
         return 0;
@@ -4619,6 +4624,7 @@ Usage:
   tapi queue create [display-name]
   tapi tapp service add <tapp> <service.call> --service-map ID --entry ENTRY
   tapi runner gui
+  tapi runner dev --tapp <tapp> [--capacity 4]
   tapi runner setup --runner-id RUNNER
   tapi runner slot set <runner-id> <slot-index> <queue-id>
   tapi services describe <servicemap.run>
@@ -4640,6 +4646,7 @@ Commands:
   tapp service add
                   Add a ServiceMap-backed service call to a Tapp
   runner gui      Open the installed desktop Runner app
+  runner dev      Run a source Runner for a Tapp development session
   runner setup    Open the legacy local browser queue/slot setup UI
   runner slot set Assign a queue to a runner slot
   services describe
@@ -4694,6 +4701,7 @@ function printRunnerHelp() {
 
 Usage:
   tapi runner gui
+  tapi runner dev --tapp <tapp> [--capacity COUNT] [--workspace PATH] [--no-watch]
   tapi runner setup --runner-id RUNNER [--port PORT] [--no-open] [--api-base-url URL]
   tapi runner slot set <runner-id> <slot-index> <queue-id> [--api-base-url URL]
 

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/package.json

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