@tilt-launcher/sdk 1.2.0

package/dist/tiltManagerSDK.js

@@ -0,0 +1,771 @@
+// src/tiltManagerSDK.ts
+import { spawn } from "node:child_process";
+import http from "node:http";
+import https from "node:https";
+import { homedir } from "node:os";
+import { basename, dirname } from "node:path";
+
+class TiltManagerSDK {
+  config;
+  maxLogLines;
+  onStatus;
+  onStatusUpdate;
+  onLogDelta;
+  onConfigMutated;
+  emittedEnvLogIndex = new Map;
+  emittedResourceLogIndex = new Map;
+  processes = new Map;
+  logs = new Map;
+  startTimes = new Map;
+  discoveredResources = new Map;
+  tiltPortReachable = new Map;
+  healthByKey = new Map;
+  newResourceCount = new Map;
+  resourceLogProcesses = new Map;
+  resourceLogs = new Map;
+  pollHandle = null;
+  wsConnections = new Map;
+  wsReconnectTimers = new Map;
+  wsEnabled = false;
+  constructor(config, options) {
+    this.config = config;
+    this.maxLogLines = options?.maxLogLines ?? 800;
+    this.onStatus = options?.onStatus;
+    this.onStatusUpdate = options?.onStatusUpdate;
+    this.onLogDelta = options?.onLogDelta;
+    this.onConfigMutated = options?.onConfigMutated;
+  }
+  setConfig(next) {
+    this.config = next;
+  }
+  currentStatusSnapshot() {
+    const envs = {};
+    for (const env of this.config.environments) {
+      envs[env.id] = {
+        status: this.getEnvState(env),
+        logs: this.logs.get(env.id) ?? [],
+        resourceLogs: this.getResourceLogsForEnv(env.id),
+        tiltPort: env.tiltPort,
+        uptime: this.startTimes.has(env.id) ? Date.now() - (this.startTimes.get(env.id) ?? Date.now()) : null,
+        newResources: this.newResourceCount.get(env.id) ?? 0,
+        resources: this.getDisplayRows(env)
+      };
+    }
+    return { envs };
+  }
+  currentStatusUpdate() {
+    const envs = {};
+    for (const env of this.config.environments) {
+      envs[env.id] = {
+        status: this.getEnvState(env),
+        tiltPort: env.tiltPort,
+        uptime: this.startTimes.has(env.id) ? Date.now() - (this.startTimes.get(env.id) ?? Date.now()) : null,
+        newResources: this.newResourceCount.get(env.id) ?? 0,
+        resources: this.getDisplayRows(env)
+      };
+    }
+    return { envs };
+  }
+  getEnvLogs(envId) {
+    return {
+      envLogs: this.logs.get(envId) ?? [],
+      resourceLogs: this.getResourceLogsForEnv(envId)
+    };
+  }
+  startPolling(intervalMs = 5000) {
+    this.wsEnabled = true;
+    if (this.pollHandle)
+      clearInterval(this.pollHandle);
+    this.pollHandle = setInterval(() => {
+      this.pollTiltState();
+    }, intervalMs);
+    this.pollTiltState();
+  }
+  stopPolling() {
+    this.wsEnabled = false;
+    if (!this.pollHandle)
+      return;
+    clearInterval(this.pollHandle);
+    this.pollHandle = null;
+    for (const envId of this.wsConnections.keys()) {
+      this.disconnectWebSocket(envId);
+    }
+  }
+  startEnv(envId) {
+    const env = this.envById(envId);
+    if (!env)
+      return { ok: false, error: "Unknown environment." };
+    if (env.external)
+      return { ok: false, error: "Cannot start an external environment." };
+    const state = this.getEnvState(env);
+    if (state === "running" || state === "starting")
+      return { ok: false, error: "Environment already active." };
+    this.appendLog(env.id, `[launcher] Starting ${env.name}...`);
+    this.appendLog(env.id, `[launcher] tilt up -f ${env.tiltfile} --port ${env.tiltPort}`);
+    const child = spawn("tilt", ["up", "-f", env.tiltfile, "--port", String(env.tiltPort)], {
+      cwd: env.repoDir,
+      detached: true,
+      stdio: ["ignore", "pipe", "pipe"],
+      env: { ...process.env, PWD: env.repoDir }
+    });
+    child.unref();
+    child.stdout?.on("data", (chunk) => {
+      for (const line of chunk.toString().split(`
+`).filter(Boolean))
+        this.appendLog(env.id, line);
+    });
+    child.stderr?.on("data", (chunk) => {
+      for (const line of chunk.toString().split(`
+`).filter(Boolean))
+        this.appendLog(env.id, line);
+    });
+    child.on("close", (code) => {
+      this.appendLog(env.id, `[launcher] Process exited with code ${code ?? 0}`);
+      this.processes.delete(env.id);
+      this.emitStatus();
+    });
+    child.on("error", (error) => {
+      this.appendLog(env.id, `[launcher] ${error.message}`);
+      this.processes.delete(env.id);
+      this.emitStatus();
+    });
+    this.processes.set(env.id, child);
+    this.startTimes.set(env.id, Date.now());
+    this.emitStatus();
+    return { ok: true };
+  }
+  stopEnv(envId) {
+    const env = this.envById(envId);
+    if (!env)
+      return { ok: false, error: "Unknown environment." };
+    this.appendLog(env.id, `[launcher] Stopping ${env.name}...`);
+    const tracked = this.processes.get(env.id);
+    if (tracked) {
+      try {
+        tracked.kill("SIGTERM");
+      } catch {}
+    }
+    const cwd = env.repoDir || homedir();
+    this.runCommand("tilt", ["down", "--port", String(env.tiltPort)], cwd);
+    this.processes.delete(env.id);
+    this.startTimes.delete(env.id);
+    this.tiltPortReachable.delete(env.id);
+    this.discoveredResources.delete(env.id);
+    for (const key of this.healthByKey.keys()) {
+      if (key.startsWith(`${env.id}:`))
+        this.healthByKey.delete(key);
+    }
+    this.disconnectWebSocket(env.id);
+    this.stopResourceLogStreams(env.id);
+    this.emitStatus();
+    return { ok: true };
+  }
+  restartEnv(envId) {
+    const env = this.envById(envId);
+    if (env?.external)
+      return { ok: false, error: "Cannot restart an external environment." };
+    const stopped = this.stopEnv(envId);
+    if (!stopped.ok)
+      return stopped;
+    return this.startEnv(envId);
+  }
+  async triggerResource(envId, resourceName) {
+    return await this.runResourceCommand(envId, ["trigger", resourceName]);
+  }
+  async enableResource(envId, resourceName) {
+    return await this.runResourceCommand(envId, ["enable", resourceName]);
+  }
+  async disableResource(envId, resourceName) {
+    return await this.runResourceCommand(envId, ["disable", resourceName]);
+  }
+  async discoverResources(input) {
+    const repoDir = dirname(input.tiltfilePath);
+    const tiltfile = basename(input.tiltfilePath);
+    const timeoutMs = input.timeoutMs ?? 30000;
+    const logsOut = [];
+    let discoveryProc;
+    try {
+      discoveryProc = spawn("tilt", ["up", "-f", tiltfile, "--port", String(input.tiltPort)], {
+        cwd: repoDir,
+        stdio: ["ignore", "pipe", "pipe"],
+        env: { ...process.env, PWD: repoDir }
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown process launch error";
+      return {
+        ok: false,
+        resources: [],
+        logs: logsOut,
+        error: `Failed to start Tilt for discovery: ${message}`
+      };
+    }
+    let spawnError = null;
+    discoveryProc.stdout?.on("data", (chunk) => {
+      logsOut.push(...chunk.toString().split(`
+`).filter(Boolean));
+    });
+    discoveryProc.stderr?.on("data", (chunk) => {
+      logsOut.push(...chunk.toString().split(`
+`).filter(Boolean));
+    });
+    discoveryProc.once("error", (error) => {
+      spawnError = error;
+      logsOut.push(`[launcher] ${error.message}`);
+    });
+    const startedAt = Date.now();
+    let resources = null;
+    while (Date.now() - startedAt < timeoutMs) {
+      if (spawnError)
+        break;
+      await new Promise((resolve) => setTimeout(resolve, 2000));
+      const env = {
+        id: "discovery",
+        name: "Discovery",
+        repoDir,
+        tiltfile,
+        tiltPort: input.tiltPort,
+        selectedResources: [],
+        cachedResources: []
+      };
+      resources = await this.readTiltResources(env);
+      if (resources && resources.length > 0)
+        break;
+    }
+    if (spawnError) {
+      return {
+        ok: false,
+        resources: [],
+        logs: logsOut,
+        error: `Failed to start Tilt for discovery: ${spawnError?.message ?? "Unknown error"}`
+      };
+    }
+    this.runCommand("tilt", ["down", "--port", String(input.tiltPort)], repoDir);
+    if (discoveryProc.pid) {
+      try {
+        process.kill(-discoveryProc.pid, "SIGTERM");
+      } catch {
+        discoveryProc.kill("SIGTERM");
+      }
+    }
+    if (!resources || resources.length === 0) {
+      return {
+        ok: false,
+        resources: [],
+        logs: logsOut,
+        error: "No resources found. The Tiltfile may have only defined the Tiltfile itself, or it failed to start within the discovery timeout."
+      };
+    }
+    return { ok: true, resources, logs: logsOut };
+  }
+  emitStatus() {
+    this.onStatus?.(this.currentStatusSnapshot());
+    if (this.onStatusUpdate) {
+      this.onStatusUpdate(this.currentStatusUpdate());
+    }
+    if (this.onLogDelta) {
+      const envLogs = {};
+      const resourceLogs = {};
+      let hasData = false;
+      for (const env of this.config.environments) {
+        const allEnvLines = this.logs.get(env.id) ?? [];
+        const prevEnv = this.emittedEnvLogIndex.get(env.id) ?? 0;
+        if (allEnvLines.length > prevEnv) {
+          envLogs[env.id] = allEnvLines.slice(prevEnv);
+          this.emittedEnvLogIndex.set(env.id, allEnvLines.length);
+          hasData = true;
+        }
+      }
+      for (const [key, lines] of this.resourceLogs) {
+        const prev = this.emittedResourceLogIndex.get(key) ?? 0;
+        if (lines.length > prev) {
+          resourceLogs[key] = lines.slice(prev);
+          this.emittedResourceLogIndex.set(key, lines.length);
+          hasData = true;
+        }
+      }
+      if (hasData) {
+        this.onLogDelta({ envLogs, resourceLogs });
+      }
+    }
+  }
+  appendLog(envId, line) {
+    const existing = this.logs.get(envId) ?? [];
+    existing.push(line);
+    this.logs.set(envId, existing.slice(-this.maxLogLines));
+  }
+  getResourceLogsForEnv(envId) {
+    const result = {};
+    const prefix = `${envId}:`;
+    for (const [key, lines] of this.resourceLogs) {
+      if (key.startsWith(prefix)) {
+        result[key.slice(prefix.length)] = lines;
+      }
+    }
+    return result;
+  }
+  startResourceLogStreams(env) {
+    const resources = this.discoveredResources.get(env.id) ?? [];
+    for (const resource of resources) {
+      const key = `${env.id}:${resource.name}`;
+      if (this.resourceLogProcesses.has(key))
+        continue;
+      const child = spawn("tilt", ["logs", "-f", resource.name, "--port", String(env.tiltPort)], {
+        cwd: env.repoDir,
+        stdio: ["ignore", "pipe", "pipe"],
+        env: { ...process.env, PWD: env.repoDir }
+      });
+      const appendResourceLog = (line) => {
+        const existing = this.resourceLogs.get(key) ?? [];
+        existing.push(line);
+        if (existing.length > this.maxLogLines) {
+          this.resourceLogs.set(key, existing.slice(-this.maxLogLines));
+        } else {
+          this.resourceLogs.set(key, existing);
+        }
+      };
+      child.stdout?.on("data", (chunk) => {
+        for (const line of chunk.toString().split(`
+`).filter(Boolean))
+          appendResourceLog(line);
+      });
+      child.stderr?.on("data", (chunk) => {
+        for (const line of chunk.toString().split(`
+`).filter(Boolean))
+          appendResourceLog(line);
+      });
+      child.on("close", () => {
+        this.resourceLogProcesses.delete(key);
+      });
+      child.on("error", () => {
+        this.resourceLogProcesses.delete(key);
+      });
+      this.resourceLogProcesses.set(key, child);
+    }
+  }
+  stopResourceLogStreams(envId) {
+    const prefix = `${envId}:`;
+    for (const [key, proc] of this.resourceLogProcesses) {
+      if (key.startsWith(prefix)) {
+        try {
+          proc.kill("SIGTERM");
+        } catch {}
+        this.resourceLogProcesses.delete(key);
+        this.resourceLogs.delete(key);
+      }
+    }
+  }
+  envById(envId) {
+    return this.config.environments.find((env) => env.id === envId);
+  }
+  getEnvState(env) {
+    const resources = this.discoveredResources.get(env.id) ?? [];
+    if (resources.some((resource) => resource.runtimeStatus === "ok"))
+      return "running";
+    if (this.tiltPortReachable.get(env.id))
+      return "running";
+    if (env.external)
+      return "stopped";
+    const proc = this.processes.get(env.id);
+    if (proc && proc.exitCode === null && !proc.killed)
+      return "starting";
+    return "stopped";
+  }
+  parseEndpoint(endpoint) {
+    if (!endpoint)
+      return {};
+    try {
+      const url = new URL(endpoint);
+      return {
+        protocol: url.protocol,
+        hostname: url.hostname,
+        port: Number(url.port || (url.protocol === "https:" ? 443 : 80)),
+        path: url.pathname || "/"
+      };
+    } catch {
+      return {};
+    }
+  }
+  absoluteEndpoint(endpoint, env) {
+    if (!endpoint)
+      return;
+    try {
+      return new URL(endpoint).toString();
+    } catch {
+      try {
+        return new URL(endpoint, `http://localhost:${env.tiltPort}`).toString();
+      } catch {
+        return;
+      }
+    }
+  }
+  categoryFor(resource) {
+    if (resource.category)
+      return resource.category;
+    if (resource.runtimeStatus === "not_applicable")
+      return "on-demand";
+    return "services";
+  }
+  async runCommand(command, args, cwd) {
+    return await new Promise((resolve) => {
+      const child = spawn(command, args, { cwd, env: { ...process.env, PWD: cwd } });
+      let output = "";
+      child.stdout.on("data", (chunk) => {
+        output += chunk.toString();
+      });
+      child.stderr.on("data", (chunk) => {
+        output += chunk.toString();
+      });
+      child.on("close", (code) => resolve({ code: code ?? 1, output }));
+      child.on("error", (err) => resolve({ code: 1, output: `${output}
+${err.message}` }));
+    });
+  }
+  async runResourceCommand(envId, args) {
+    const env = this.envById(envId);
+    if (!env)
+      return { ok: false, error: "Unknown environment." };
+    const command = ["tilt", ...args, "--port", String(env.tiltPort)].join(" ");
+    this.appendLog(env.id, `[launcher] ${command}`);
+    const cwd = env.repoDir || homedir();
+    const result = await this.runCommand("tilt", [...args, "--port", String(env.tiltPort)], cwd);
+    if (result.code !== 0) {
+      const detail2 = result.output.trim();
+      if (detail2)
+        this.appendLog(env.id, detail2);
+      this.emitStatus();
+      return { ok: false, error: detail2 || `Command failed: ${command}` };
+    }
+    const detail = result.output.trim();
+    if (detail)
+      this.appendLog(env.id, detail);
+    await this.pollTiltState();
+    return { ok: true };
+  }
+  parseUIResource(item, env) {
+    const endpoint = this.absoluteEndpoint(item.status?.endpointLinks?.[0]?.url, env);
+    const parsedEndpoint = this.parseEndpoint(endpoint);
+    const labels = item.metadata?.labels ? Object.keys(item.metadata.labels) : [];
+    const disableState = (item.status?.disableStatus?.state ?? "").toLowerCase();
+    const isDisabled = disableState === "disabled" || disableState === "pending";
+    const runtimeStatus = isDisabled ? "disabled" : item.status?.runtimeStatus ?? "unknown";
+    const resourceKind = runtimeStatus === "not_applicable" || runtimeStatus === "disabled" ? "cmd" : runtimeStatus === "ok" || runtimeStatus === "pending" || runtimeStatus === "error" ? "serve" : "unknown";
+    const buildHistory = item.status?.buildHistory;
+    const lastBuild = buildHistory?.[0];
+    const lastBuildDuration = lastBuild?.startTime && lastBuild?.finishTime ? (new Date(lastBuild.finishTime).getTime() - new Date(lastBuild.startTime).getTime()) / 1000 : undefined;
+    const waiting = item.status?.waiting;
+    const rawConditions = item.status?.conditions;
+    const conditions = rawConditions?.map((c) => ({
+      type: c.type ?? "",
+      status: c.status ?? "",
+      ...c.lastTransitionTime != null ? { lastTransitionTime: c.lastTransitionTime } : {}
+    }));
+    const rawPid = item.status?.localResourceInfo?.pid;
+    const pid = rawPid ? Number(rawPid) : undefined;
+    return {
+      name: item.metadata?.name ?? "unknown",
+      label: item.metadata?.name ?? "unknown",
+      category: labels[0] ?? "services",
+      type: item.status?.specs?.[0]?.type ?? "unknown",
+      endpoint,
+      port: parsedEndpoint.port,
+      path: parsedEndpoint.path,
+      runtimeStatus,
+      isDisabled,
+      resourceKind,
+      updateStatus: item.status?.updateStatus,
+      waitingReason: waiting?.reason,
+      waitingOn: waiting?.on?.map((ref) => ref.name ?? "").filter(Boolean),
+      lastDeployTime: item.status?.lastDeployTime,
+      lastBuildDuration,
+      lastBuildError: lastBuild?.error,
+      hasPendingChanges: item.status?.hasPendingChanges,
+      triggerMode: item.status?.triggerMode,
+      queued: item.status?.queued,
+      order: item.status?.order,
+      pid,
+      conditions
+    };
+  }
+  async readTiltResources(env) {
+    const result = await this.runCommand("tilt", ["get", "uiresources", "-o", "json", "--port", String(env.tiltPort)], env.repoDir);
+    if (result.code !== 0)
+      return null;
+    try {
+      const parsed = JSON.parse(result.output);
+      return (parsed.items ?? []).filter((item) => item.metadata?.name && item.metadata.name !== "(Tiltfile)").map((item) => this.parseUIResource(item, env));
+    } catch {
+      return null;
+    }
+  }
+  async tryConnect(hostname, port, path = "/", protocol = "http:") {
+    return await new Promise((resolve) => {
+      const client = protocol === "https:" ? https : http;
+      const request = client.request({
+        hostname,
+        port,
+        path,
+        method: "GET",
+        timeout: 1500
+      }, (response) => {
+        response.resume();
+        resolve(true);
+      });
+      request.on("error", () => resolve(false));
+      request.on("timeout", () => {
+        request.destroy();
+        resolve(false);
+      });
+      request.end();
+    });
+  }
+  runtimeHealth(resource) {
+    if (resource.isDisabled)
+      return "unknown";
+    const runtime = (resource.runtimeStatus ?? "").toLowerCase();
+    if (runtime === "ok")
+      return "up";
+    if (runtime === "not_applicable" || runtime === "")
+      return "unknown";
+    return "down";
+  }
+  async computeHealth(resource, env) {
+    const runtimeDerived = this.runtimeHealth(resource);
+    if (resource.isDisabled)
+      return runtimeDerived;
+    if (runtimeDerived === "up" || runtimeDerived === "down")
+      return runtimeDerived;
+    const parsed = this.parseEndpoint(resource.endpoint);
+    const path = parsed.path ?? resource.path ?? "/";
+    const protocol = parsed.protocol === "https:" ? "https:" : "http:";
+    if (parsed.hostname === "localhost" && parsed.port === env.tiltPort) {
+      return runtimeDerived;
+    }
+    if (parsed.hostname && parsed.port) {
+      const direct = await this.tryConnect(parsed.hostname, parsed.port, path, protocol);
+      if (direct)
+        return "up";
+      if (parsed.hostname === "localhost") {
+        const loopback = await this.tryConnect("127.0.0.1", parsed.port, path, protocol) || await this.tryConnect("::1", parsed.port, path, protocol);
+        if (loopback)
+          return "up";
+      }
+      return runtimeDerived;
+    }
+    if (!resource.port)
+      return runtimeDerived;
+    const ok = await this.tryConnect("127.0.0.1", resource.port, path, protocol) || await this.tryConnect("::1", resource.port, path, protocol);
+    if (ok)
+      return "up";
+    return runtimeDerived;
+  }
+  getDisplayRows(env) {
+    const selected = env.selectedResources ?? [];
+    const discovered = this.discoveredResources.get(env.id) ?? [];
+    const cached = env.cachedResources ?? [];
+    const byName = new Map;
+    for (const resource of cached)
+      byName.set(resource.name, resource);
+    for (const resource of discovered)
+      byName.set(resource.name, resource);
+    return selected.map((name) => {
+      const key = `${env.id}:${name}`;
+      const found = byName.get(name);
+      if (!found) {
+        return {
+          key,
+          name,
+          label: name,
+          category: "services",
+          runtimeStatus: "missing",
+          isDisabled: false,
+          health: "missing",
+          exists: false,
+          error: `Resource '${name}' not found in Tiltfile output.`,
+          resourceKind: "unknown"
+        };
+      }
+      return {
+        key,
+        name: found.name,
+        label: found.label || found.name,
+        category: this.categoryFor(found),
+        endpoint: found.endpoint,
+        port: found.port,
+        path: found.path,
+        runtimeStatus: found.runtimeStatus ?? "unknown",
+        isDisabled: found.isDisabled ?? false,
+        health: this.healthByKey.get(key) ?? "unknown",
+        exists: true,
+        resourceKind: found.resourceKind ?? "unknown",
+        updateStatus: found.updateStatus,
+        waitingReason: found.waitingReason,
+        waitingOn: found.waitingOn,
+        lastDeployTime: found.lastDeployTime,
+        lastBuildDuration: found.lastBuildDuration,
+        lastBuildError: found.lastBuildError,
+        hasPendingChanges: found.hasPendingChanges,
+        triggerMode: found.triggerMode,
+        queued: found.queued,
+        order: found.order,
+        pid: found.pid,
+        conditions: found.conditions
+      };
+    });
+  }
+  async connectWebSocket(env) {
+    if (this.wsConnections.has(env.id))
+      return;
+    const tokenUrl = `http://127.0.0.1:${env.tiltPort}/api/websocket_token`;
+    let token;
+    try {
+      const resp = await fetch(tokenUrl);
+      if (!resp.ok)
+        return;
+      token = (await resp.text()).trim();
+    } catch {
+      return;
+    }
+    const wsUrl = `ws://127.0.0.1:${env.tiltPort}/ws/view?token=${token}`;
+    const ws = new WebSocket(wsUrl);
+    ws.onopen = () => {
+      this.appendLog(env.id, "[launcher] WebSocket connected");
+    };
+    ws.onmessage = (event) => {
+      try {
+        const data = JSON.parse(typeof event.data === "string" ? event.data : event.data.toString());
+        this.handleWSMessage(env, data);
+      } catch {}
+    };
+    ws.onerror = () => {};
+    ws.onclose = () => {
+      this.wsConnections.delete(env.id);
+      if (this.wsEnabled && this.processes.has(env.id)) {
+        const timer = setTimeout(() => {
+          this.wsReconnectTimers.delete(env.id);
+          this.connectWebSocket(env);
+        }, 3000);
+        this.wsReconnectTimers.set(env.id, timer);
+      }
+    };
+    this.wsConnections.set(env.id, ws);
+  }
+  disconnectWebSocket(envId) {
+    const timer = this.wsReconnectTimers.get(envId);
+    if (timer) {
+      clearTimeout(timer);
+      this.wsReconnectTimers.delete(envId);
+    }
+    const ws = this.wsConnections.get(envId);
+    if (ws) {
+      try {
+        ws.close();
+      } catch {}
+      this.wsConnections.delete(envId);
+    }
+  }
+  handleWSMessage(env, data) {
+    if (data.uiResources && Array.isArray(data.uiResources)) {
+      const incoming = data.uiResources.filter((item) => item.metadata?.name && item.metadata.name !== "(Tiltfile)").map((item) => this.parseUIResource(item, env));
+      if (incoming.length > 0) {
+        const existing = this.discoveredResources.get(env.id) ?? [];
+        const byName = new Map;
+        for (const r of existing)
+          byName.set(r.name, r);
+        for (const r of incoming)
+          byName.set(r.name, r);
+        const merged = Array.from(byName.values());
+        this.discoveredResources.set(env.id, merged);
+        this.tiltPortReachable.set(env.id, true);
+        const selected = new Set(env.selectedResources ?? []);
+        if (env.external) {
+          env.selectedResources = merged.map((r) => r.name);
+          this.newResourceCount.set(env.id, 0);
+          this.onConfigMutated?.(this.config);
+        } else {
+          this.newResourceCount.set(env.id, merged.filter((r) => !selected.has(r.name)).length);
+        }
+        env.cachedResources = [...merged];
+        for (const resource of incoming) {
+          const key = `${env.id}:${resource.name}`;
+          this.healthByKey.set(key, this.runtimeHealth(resource));
+        }
+      }
+    }
+    if (data.logList?.segments && Array.isArray(data.logList.segments)) {
+      const spans = data.logList.spans;
+      for (const seg of data.logList.segments) {
+        const text = seg.text?.trimEnd();
+        if (!text)
+          continue;
+        const manifestName = seg.spanId && spans?.[seg.spanId]?.manifestName;
+        if (manifestName && manifestName !== "(Tiltfile)") {
+          const key = `${env.id}:${manifestName}`;
+          const existing = this.resourceLogs.get(key) ?? [];
+          existing.push(text);
+          if (existing.length > this.maxLogLines) {
+            this.resourceLogs.set(key, existing.slice(-this.maxLogLines));
+          } else {
+            this.resourceLogs.set(key, existing);
+          }
+        }
+        this.appendLog(env.id, text);
+      }
+    }
+    this.emitStatus();
+  }
+  async pollTiltState() {
+    for (const env of this.config.environments) {
+      const ws = this.wsConnections.get(env.id);
+      if (ws && ws.readyState === WebSocket.OPEN) {
+        const mergedByName2 = new Map;
+        for (const resource of this.discoveredResources.get(env.id) ?? [])
+          mergedByName2.set(resource.name, resource);
+        for (const resourceName of env.selectedResources ?? []) {
+          const resource = mergedByName2.get(resourceName);
+          if (!resource?.endpoint)
+            continue;
+          const key = `${env.id}:${resource.name}`;
+          this.healthByKey.set(key, await this.computeHealth(resource, env));
+        }
+        continue;
+      }
+      const tiltIsReachable = await this.tryConnect("127.0.0.1", env.tiltPort, "/") || await this.tryConnect("::1", env.tiltPort, "/");
+      this.tiltPortReachable.set(env.id, tiltIsReachable);
+      if (tiltIsReachable && !this.wsConnections.has(env.id) && this.wsEnabled) {
+        this.connectWebSocket(env);
+      }
+      const resources = await this.readTiltResources(env);
+      if (resources) {
+        this.discoveredResources.set(env.id, resources);
+        const selected = new Set(env.selectedResources ?? []);
+        if (env.external) {
+          env.selectedResources = resources.map((r) => r.name);
+          this.newResourceCount.set(env.id, 0);
+          this.onConfigMutated?.(this.config);
+        } else {
+          this.newResourceCount.set(env.id, resources.filter((resource) => !selected.has(resource.name)).length);
+        }
+        env.cachedResources = [...resources];
+        if (tiltIsReachable && !this.wsConnections.has(env.id)) {
+          this.startResourceLogStreams(env);
+        }
+      }
+      const mergedByName = new Map;
+      for (const resource of env.cachedResources ?? [])
+        mergedByName.set(resource.name, resource);
+      for (const resource of this.discoveredResources.get(env.id) ?? [])
+        mergedByName.set(resource.name, resource);
+      for (const resourceName of env.selectedResources ?? []) {
+        const resource = mergedByName.get(resourceName);
+        if (!resource)
+          continue;
+        const key = `${env.id}:${resource.name}`;
+        this.healthByKey.set(key, await this.computeHealth(resource, env));
+      }
+    }
+    this.emitStatus();
+  }
+}
+export {
+  TiltManagerSDK
+};