talon-agent 3.33.4 → 3.34.0

package/src/core/engine/backend-controller/state.ts

@@ -29,6 +29,8 @@ export interface PoolEntry {
 
 /** id → entry. */
 export const pool = new Map<string, PoolEntry>();
+/** id → init in progress; concurrent callers await the same promise. */
+export const initInFlight = new Map<string, Promise<PoolEntry>>();
 /** holder → backend id (only present for holders currently bound). */
 export const bindings = new Map<BackendHolder, string>();
 
@@ -56,6 +58,8 @@ export async function ensurePoolEntry(
 ): Promise<PoolEntry> {
   const existing = pool.get(id);
   if (existing) return existing;
+  const inFlight = initInFlight.get(id);
+  if (inFlight) return inFlight;
 
   const factory = getBackend(id);
   if (!factory) {
@@ -64,22 +68,31 @@ export async function ensurePoolEntry(
       .join(", ");
     throw new Error(`Unknown backend "${id}" — known: ${known}`);
   }
-  if (!ctx.initCtx) {
+  const initCtx = ctx.initCtx;
+  if (!initCtx) {
     throw new Error(
       "Backend pool not initialised — call initBackendPool first",
     );
   }
-  const instance = await factory.init(config, ctx.initCtx);
-  const entry: PoolEntry = {
-    id: factory.id,
-    label: factory.label,
-    backend: instance.backend,
-    cleanup: instance.cleanup,
-    holders: new Set(),
-  };
-  pool.set(factory.id, entry);
-  log("backend-controller", `Pool init: ${factory.label} (${factory.id})`);
-  return entry;
+  const init = (async (): Promise<PoolEntry> => {
+    const instance = await factory.init(config, initCtx);
+    const entry: PoolEntry = {
+      id: factory.id,
+      label: factory.label,
+      backend: instance.backend,
+      cleanup: instance.cleanup,
+      holders: new Set(),
+    };
+    pool.set(factory.id, entry);
+    log("backend-controller", `Pool init: ${factory.label} (${factory.id})`);
+    return entry;
+  })();
+  initInFlight.set(id, init);
+  try {
+    return await init;
+  } finally {
+    initInFlight.delete(id);
+  }
 }
 
 /** Drop a holder from an entry; clean up the entry if its refcount hits zero. */

package/src/core/engine/gateway-actions/cron.ts

@@ -8,14 +8,12 @@ import {
   getCronJobsForChat,
   updateCronJob,
   deleteCronJob,
-  validateCronExpression,
   generateCronId,
   describeSchedule,
   nextRunAt,
-  type CronJobType,
-  type CatchupPolicy,
 } from "../../../storage/cron-store.js";
 import { runJobNow } from "../../background/cron.js";
+import { parseCronSpec } from "../../background/cron-spec.js";
 import { log } from "../../../util/log.js";
 import type { Backend } from "../../agent-runtime/capabilities.js";
 import {
@@ -27,31 +25,6 @@ import {
 import { validateJobModelOverride } from "./shared.js";
 import type { SharedActionHandlers } from "./types.js";
 
-// ── Scheduler field parsing (shared by create/edit cron) ────────────────────
-
-/** The scheduler ticks once a minute, so sub-minute intervals are meaningless. */
-const MIN_INTERVAL_SECONDS = 60;
-const CATCHUP_POLICIES = new Set<CatchupPolicy>(["skip", "once", "all"]);
-
-/** True for a body field that was actually supplied (not absent/blank). */
-function provided(v: unknown): boolean {
-  return v !== undefined && v !== null && v !== "";
-}
-
-/**
- * Parse an instant given as an ISO-8601 string or epoch-ms number into epoch
- * ms. Returns undefined when the field is absent or unparseable — callers
- * distinguish the two via `provided()`.
- */
-function parseInstant(v: unknown): number | undefined {
-  if (!provided(v)) return undefined;
-  if (typeof v === "number") return Number.isFinite(v) ? v : undefined;
-  const s = String(v).trim();
-  if (/^\d+$/.test(s)) return Number(s);
-  const d = Date.parse(s);
-  return Number.isFinite(d) ? d : undefined;
-}
-
 /**
  * Validate a cron `query` job's model + optional provider override. Cron runs
  * isolated, so unlike triggers it may target a different provider — the backend
@@ -113,147 +86,38 @@ function validateCronBackgroundCapability(
 
 export const cronHandlers: SharedActionHandlers = {
   create_cron_job: async (body, chatId) => {
-    const name = String(body.name ?? "Unnamed job");
-    const jobType = (body.type as CronJobType) ?? "message";
-    const content = String(body.content ?? "");
-    const timezone = body.timezone ? String(body.timezone) : undefined;
-    const model = body.model ? String(body.model) : undefined;
-    const provider = body.provider ? String(body.provider) : undefined;
-    const instructions = body.instructions
-      ? String(body.instructions)
-      : undefined;
-
-    if (!content) return { ok: false, error: "Missing content" };
-    if (content.length > 10_000)
-      return { ok: false, error: "Content too long (max 10,000 chars)" };
-
-    // Cadence: exactly one of `schedule` (cron expression) or
-    // `every_seconds` (fixed interval).
-    const schedule = provided(body.schedule)
-      ? String(body.schedule)
-      : undefined;
-    const hasEvery = provided(body.every_seconds);
-    if (!schedule && !hasEvery)
-      return {
-        ok: false,
-        error:
-          "Provide either 'schedule' (a cron expression) or 'every_seconds' (a fixed interval).",
-      };
-    if (schedule && hasEvery)
-      return {
-        ok: false,
-        error: "Provide only one of 'schedule' or 'every_seconds', not both.",
-      };
-
-    let everyMs: number | undefined;
-    if (hasEvery) {
-      const everySeconds = Number(body.every_seconds);
-      if (!Number.isFinite(everySeconds) || everySeconds < MIN_INTERVAL_SECONDS)
-        return {
-          ok: false,
-          error: `'every_seconds' must be a number >= ${MIN_INTERVAL_SECONDS} (the scheduler ticks once a minute).`,
-        };
-      everyMs = Math.round(everySeconds * 1000);
-    }
-
-    if (schedule) {
-      const validation = validateCronExpression(schedule, timezone);
-      if (!validation.valid)
-        return {
-          ok: false,
-          error: `Invalid cron expression: ${validation.error}`,
-        };
-    }
-
-    // Lifecycle bounds.
-    const startAt = parseInstant(body.start_at);
-    if (provided(body.start_at) && startAt === undefined)
-      return {
-        ok: false,
-        error:
-          "Could not parse 'start_at' (use an ISO-8601 timestamp or epoch ms).",
-      };
-    const endAt = parseInstant(body.end_at);
-    if (provided(body.end_at) && endAt === undefined)
-      return {
-        ok: false,
-        error:
-          "Could not parse 'end_at' (use an ISO-8601 timestamp or epoch ms).",
-      };
-    if (startAt !== undefined && endAt !== undefined && endAt <= startAt)
-      return { ok: false, error: "'end_at' must be after 'start_at'." };
-    if (endAt !== undefined && endAt <= Date.now())
-      return {
-        ok: false,
-        error: "'end_at' is in the past — the job would never run.",
-      };
-
-    // Run cap. `once: true` is sugar for max_runs = 1 (one-shot).
-    let maxRuns: number | undefined;
-    if (body.once === true) maxRuns = 1;
-    else if (provided(body.max_runs)) {
-      const m = Number(body.max_runs);
-      if (!Number.isInteger(m) || m < 1)
-        return { ok: false, error: "'max_runs' must be a positive integer." };
-      maxRuns = m;
-    }
-
-    // Missed-run catch-up policy. New jobs default to "once": a run that
-    // came due while Talon was down (or while the scheduler was wedged)
-    // replays a single time at startup instead of being lost silently — a
-    // live audit found one-shot reminders that missed their date under the
-    // old "skip" default and quietly rolled over a full year. Explicit
-    // "skip" remains available for jobs where a late run is worthless.
-    let catchup: CatchupPolicy = "once";
-    if (provided(body.catchup)) {
-      catchup = String(body.catchup) as CatchupPolicy;
-      if (!CATCHUP_POLICIES.has(catchup))
-        return {
-          ok: false,
-          error: "'catchup' must be one of: skip, once, all.",
-        };
-    }
-
-    // The overrides only make sense for "query" jobs (a "message" job just
-    // sends text — no model runs).
-    if ((model || provider || instructions) && jobType !== "query")
-      return {
-        ok: false,
-        error: "Model/provider/instructions only apply to 'query' jobs.",
-      };
-    if (provider && !model)
-      return {
-        ok: false,
-        error: "A 'provider' override also requires a 'model'.",
-      };
+    const parsed = parseCronSpec(body);
+    if (!parsed.ok) return { ok: false, error: parsed.error };
+    const spec = parsed.effective;
+    const {
+      name,
+      type: jobType,
+      schedule,
+      everyMs,
+      startAt,
+      endAt,
+      maxRuns,
+    } = spec;
 
     // Validate the target backend/model up front so a bad id or unsupported
     // backend is rejected here instead of silently failing at fire time.
     if (jobType === "query") {
-      const modelErr = await validateCronModelOverride(chatId, model, provider);
+      const modelErr = await validateCronModelOverride(
+        chatId,
+        spec.model,
+        spec.provider,
+      );
       if (modelErr) return { ok: false, error: modelErr };
     }
 
     const id = generateCronId();
     addCronJob({
+      ...spec,
       id,
       chatId: String(chatId),
-      type: jobType,
-      content,
-      name,
       enabled: true,
       createdAt: Date.now(),
       runCount: 0,
-      timezone,
-      ...(schedule ? { schedule } : {}),
-      ...(everyMs !== undefined ? { everyMs } : {}),
-      ...(startAt !== undefined ? { startAt } : {}),
-      ...(endAt !== undefined ? { endAt } : {}),
-      ...(maxRuns !== undefined ? { maxRuns } : {}),
-      catchup,
-      ...(model ? { model } : {}),
-      ...(provider ? { provider } : {}),
-      ...(instructions ? { instructions } : {}),
     });
     log(
       "gateway",
@@ -268,7 +132,7 @@ export const cronHandlers: SharedActionHandlers = {
         ? `starts: ${new Date(startAt).toISOString()}`
         : null,
       endAt !== undefined ? `ends: ${new Date(endAt).toISOString()}` : null,
-      catchup ? `catch-up: ${catchup}` : null,
+      spec.catchup ? `catch-up: ${spec.catchup}` : null,
     ]
       .filter(Boolean)
       .join(", ");
@@ -335,157 +199,29 @@ export const cronHandlers: SharedActionHandlers = {
     if (job.chatId !== String(chatId))
       return { ok: false, error: "Job belongs to a different chat" };
 
-    const updates: Record<string, unknown> = {};
-    if (body.name !== undefined) updates.name = String(body.name);
-    if (body.content !== undefined) updates.content = String(body.content);
-    if (body.enabled !== undefined) updates.enabled = Boolean(body.enabled);
-    if (body.type !== undefined) updates.type = String(body.type);
-    if (body.timezone !== undefined)
-      updates.timezone = body.timezone ? String(body.timezone) : undefined;
-
-    // Cadence — schedule and every_seconds are mutually exclusive; setting
-    // one switches mode and clears the other.
-    const editSchedule = body.schedule !== undefined;
-    const editEvery = provided(body.every_seconds);
-    if (editSchedule && provided(body.schedule) && editEvery)
-      return {
-        ok: false,
-        error: "Provide only one of 'schedule' or 'every_seconds', not both.",
-      };
-    if (editSchedule && provided(body.schedule)) {
-      const tz = (updates.timezone as string | undefined) ?? job.timezone;
-      const v = validateCronExpression(String(body.schedule), tz);
-      if (!v.valid)
-        return { ok: false, error: `Invalid cron expression: ${v.error}` };
-      updates.schedule = String(body.schedule);
-      updates.everyMs = undefined;
-    }
-    if (editEvery) {
-      const everySeconds = Number(body.every_seconds);
-      if (!Number.isFinite(everySeconds) || everySeconds < MIN_INTERVAL_SECONDS)
-        return {
-          ok: false,
-          error: `'every_seconds' must be a number >= ${MIN_INTERVAL_SECONDS}.`,
-        };
-      updates.everyMs = Math.round(everySeconds * 1000);
-      updates.schedule = undefined;
-    }
+    const parsed = parseCronSpec(body, job);
+    if (!parsed.ok) return { ok: false, error: parsed.error };
+    const { updates, effective } = parsed;
 
-    // Lifecycle bounds (pass null/"" to clear).
-    if (body.start_at !== undefined) {
-      if (!provided(body.start_at)) updates.startAt = undefined;
-      else {
-        const s = parseInstant(body.start_at);
-        if (s === undefined)
-          return { ok: false, error: "Could not parse 'start_at'." };
-        updates.startAt = s;
-      }
-    }
-    if (body.end_at !== undefined) {
-      if (!provided(body.end_at)) updates.endAt = undefined;
-      else {
-        const e = parseInstant(body.end_at);
-        if (e === undefined)
-          return { ok: false, error: "Could not parse 'end_at'." };
-        if (e <= Date.now())
-          return {
-            ok: false,
-            error: "'end_at' is in the past — the job would never run.",
-          };
-        updates.endAt = e;
-      }
-    }
-    if (body.once === true) updates.maxRuns = 1;
-    else if (body.max_runs !== undefined) {
-      if (!provided(body.max_runs)) updates.maxRuns = undefined;
-      else {
-        const m = Number(body.max_runs);
-        if (!Number.isInteger(m) || m < 1)
-          return {
-            ok: false,
-            error: "'max_runs' must be a positive integer.",
-          };
-        updates.maxRuns = m;
-      }
-    }
-    if (body.catchup !== undefined) {
-      const c = String(body.catchup) as CatchupPolicy;
-      if (!CATCHUP_POLICIES.has(c))
-        return {
-          ok: false,
-          error: "'catchup' must be one of: skip, once, all.",
-        };
-      updates.catchup = c;
-    }
-    if (body.model !== undefined) {
-      updates.model = provided(body.model) ? String(body.model) : undefined;
-    }
-    if (body.provider !== undefined) {
-      updates.provider = provided(body.provider)
-        ? String(body.provider)
-        : undefined;
-    }
-    if (body.instructions !== undefined) {
-      updates.instructions = provided(body.instructions)
-        ? String(body.instructions)
-        : undefined;
-    }
-
-    // Query execution overrides only apply to 'query' jobs — mirror create.
     // Validate the effective post-edit target so provider+model edits are
     // checked together using cron's cross-provider rules.
-    const effType = (updates.type as CronJobType | undefined) ?? job.type;
-    const effModel =
-      "model" in updates ? (updates.model as string | undefined) : job.model;
-    const effProvider =
-      "provider" in updates
-        ? (updates.provider as string | undefined)
-        : job.provider;
-    const effInstructions =
-      "instructions" in updates
-        ? (updates.instructions as string | undefined)
-        : job.instructions;
-    if (effType !== "query" && (effModel || effProvider || effInstructions))
-      return {
-        ok: false,
-        error: "Model/provider/instructions only apply to 'query' jobs.",
-      };
-    if (effProvider && !effModel)
-      return {
-        ok: false,
-        error: "A 'provider' override also requires a 'model'.",
-      };
     if (
-      effType === "query" &&
+      effective.type === "query" &&
       ("model" in updates || "provider" in updates || "type" in updates)
     ) {
       const modelErr = await validateCronModelOverride(
         chatId,
-        effModel,
-        effProvider,
+        effective.model,
+        effective.provider,
       );
       if (modelErr) return { ok: false, error: modelErr };
     }
 
-    // Reject a start/end window that can never fire, accounting for the merge.
-    const effStart =
-      "startAt" in updates
-        ? (updates.startAt as number | undefined)
-        : job.startAt;
-    const effEnd =
-      "endAt" in updates ? (updates.endAt as number | undefined) : job.endAt;
-    if (effStart !== undefined && effEnd !== undefined && effEnd <= effStart)
-      return { ok: false, error: "'end_at' must be after 'start_at'." };
-
     // If a lowered run cap already met/exceeds runCount, retire the job now so
     // it can't sneak one more run before enforceRunCap catches it post-run.
-    const effMaxRuns =
-      "maxRuns" in updates
-        ? (updates.maxRuns as number | undefined)
-        : job.maxRuns;
     if (
-      effMaxRuns !== undefined &&
-      job.runCount >= effMaxRuns &&
+      effective.maxRuns !== undefined &&
+      job.runCount >= effective.maxRuns &&
       updates.enabled !== true
     )
       updates.enabled = false;

package/src/core/engine/gateway-routes.ts

@@ -0,0 +1,239 @@
+/**
+ * The action gateway's HTTP routes — declared once, in order, rather than
+ * implied by where an `if` sits in `Gateway.start`. Every route shares the
+ * 127.0.0.1 trust boundary; the table is the list a reviewer reads.
+ */
+import type { IncomingMessage, Server, ServerResponse } from "node:http";
+import { bus } from "../bus/index.js";
+import { taskTable } from "../tasks/index.js";
+import { handleHubRequest, HUB_PATH_PREFIX } from "../mcp-hub/index.js";
+import { log, logError } from "../../util/log.js";
+
+/** What the routes need from the Gateway that owns them. */
+export type GatewayRouteHost = {
+  /** The /health body — identity fields plus live counters. */
+  healthSnapshot: () => Record<string, unknown>;
+  /** Schedule a graceful stop; false when this process cannot be stopped this way. */
+  requestShutdown: () => boolean;
+  /** Hot-reload plugins from config; resolves to the loaded plugin names. */
+  reloadPlugins: () => Promise<string[]>;
+  /** Origin the MCP hub advertises for its own endpoints. */
+  hubOrigin: () => string;
+  /** The /action body handler. */
+  handleAction: (body: Record<string, unknown>) => Promise<unknown>;
+};
+
+type RouteContext = {
+  req: IncomingMessage;
+  res: ServerResponse;
+  url: URL;
+  host: GatewayRouteHost;
+};
+
+type GatewayRoute = {
+  method: "GET" | "POST" | "ANY";
+  path: string;
+  /** `prefix` matches `path` as a leading segment; default is an exact match. */
+  match?: "prefix";
+  handle: (ctx: RouteContext) => void | Promise<void>;
+};
+
+function sendJson(res: ServerResponse, status: number, body: unknown): void {
+  // Serialise before writing headers: a body that cannot be stringified
+  // must surface as a 500, not as a half-sent 200 that never ends.
+  const json = JSON.stringify(body);
+  res.writeHead(status, { "Content-Type": "application/json" });
+  res.end(json);
+}
+
+async function readJsonBody(req: IncomingMessage): Promise<unknown> {
+  const chunks: Buffer[] = [];
+  for await (const chunk of req) chunks.push(chunk as Buffer);
+  return JSON.parse(Buffer.concat(chunks).toString("utf-8"));
+}
+
+const ROUTES: readonly GatewayRoute[] = [
+  {
+    method: "GET",
+    path: "/health",
+    handle: ({ res, host }) => sendJson(res, 200, host.healthSnapshot()),
+  },
+  {
+    // Graceful stop for `talon stop`/`talon restart`. Respond before
+    // triggering so the client isn't cut off mid-request; the shutdown
+    // path takes seconds, so the reply flushes safely.
+    method: "POST",
+    path: "/shutdown",
+    handle: ({ res, host }) => {
+      if (!host.requestShutdown()) {
+        sendJson(res, 501, {
+          ok: false,
+          error: "Shutdown not supported by this process",
+        });
+        return;
+      }
+      sendJson(res, 200, { ok: true });
+    },
+  },
+  {
+    // Bus tail — recent events, optionally after a cursor. Read by `talon events`.
+    method: "GET",
+    path: "/events/recent",
+    match: "prefix",
+    handle: ({ res, url }) => {
+      const since = Number(url.searchParams.get("since") ?? "0");
+      sendJson(res, 200, {
+        ok: true,
+        events: bus.recent(Number.isInteger(since) && since > 0 ? since : 0),
+      });
+    },
+  },
+  {
+    // The task table — every live/recent unit of agent work. Read by `talon ps`.
+    method: "GET",
+    path: "/tasks",
+    handle: ({ res }) =>
+      sendJson(res, 200, { ok: true, tasks: taskTable.list() }),
+  },
+  {
+    // Abort one killable task by id — the transport for `talon kill`.
+    method: "POST",
+    path: "/tasks/kill",
+    handle: async ({ req, res }) => {
+      let id: unknown;
+      try {
+        id = ((await readJsonBody(req)) as { id?: unknown }).id;
+      } catch {
+        sendJson(res, 400, { ok: false, error: "Invalid JSON" });
+        return;
+      }
+      if (typeof id !== "number" || !Number.isInteger(id)) {
+        sendJson(res, 400, { ok: false, error: "id must be an integer" });
+        return;
+      }
+      sendJson(res, 200, taskTable.kill(id));
+    },
+  },
+  {
+    // Hot-reload plugins from config — the transport for `talon plugin
+    // install/enable/disable`, which has no chat context and so cannot use
+    // the reload_plugins action.
+    method: "POST",
+    path: "/plugins/reload",
+    handle: async ({ res, host }) => {
+      try {
+        const loaded = await host.reloadPlugins();
+        log("gateway", `/plugins/reload: ${loaded.length} plugins loaded`);
+        sendJson(res, 200, { ok: true, loaded });
+      } catch (err) {
+        sendJson(res, 200, {
+          ok: false,
+          error: `Plugin reload failed: ${err instanceof Error ? err.message : err}`,
+        });
+      }
+    },
+  },
+  {
+    // MCP hub — daemon-hosted MCP-over-HTTP endpoints for every backend
+    // (see core/mcp-hub).
+    method: "ANY",
+    path: HUB_PATH_PREFIX,
+    match: "prefix",
+    handle: ({ req, res, host }) =>
+      handleHubRequest(req, res, host.hubOrigin()),
+  },
+  {
+    method: "POST",
+    path: "/action",
+    handle: async ({ req, res, host }) => {
+      let body: Record<string, unknown>;
+      try {
+        body = (await readJsonBody(req)) as Record<string, unknown>;
+      } catch {
+        sendJson(res, 400, { ok: false, error: "Invalid JSON" });
+        return;
+      }
+      sendJson(res, 200, await host.handleAction(body));
+    },
+  },
+];
+
+function matches(route: GatewayRoute, req: IncomingMessage): boolean {
+  if (route.method !== "ANY" && req.method !== route.method) return false;
+  const url = req.url ?? "";
+  return route.match === "prefix"
+    ? url.startsWith(route.path)
+    : url === route.path;
+}
+
+/** Serve one request: first matching route wins; nothing matches → 404. */
+export async function dispatchGatewayRoute(
+  req: IncomingMessage,
+  res: ServerResponse,
+  host: GatewayRouteHost,
+): Promise<void> {
+  const route = ROUTES.find((candidate) => matches(candidate, req));
+  if (!route) {
+    res.writeHead(404);
+    res.end("Not found");
+    return;
+  }
+  try {
+    await route.handle({
+      req,
+      res,
+      url: new URL(req.url ?? "/", "http://gateway"),
+      host,
+    });
+  } catch (err) {
+    if (res.headersSent) return;
+    // Log full error (incl. stack via logError's structured `stack` field)
+    // on the server; return a generic message to the client so we don't
+    // leak implementation details. CodeQL: js/stack-trace-exposure.
+    logError("gateway", `Unhandled error on ${req.method} ${req.url}`, err);
+    sendJson(res, 500, { ok: false, error: "Internal server error" });
+  }
+}
+
+const PORT_RETRIES = 5;
+
+/**
+ * Bind to 127.0.0.1, walking up from `port` on EADDRINUSE (at most
+ * `PORT_RETRIES` times). Resolves with the port actually bound — `port`
+ * 0 asks the OS for a free one — and leaves a persistent error handler
+ * on the server, so a later server-level error is logged instead of
+ * crashing the process via an unhandled 'error' event.
+ */
+export function listenWithRetry(server: Server, port: number): Promise<number> {
+  return new Promise<number>((resolve, reject) => {
+    let attempt = 0;
+    const tryPort = (candidate: number): void => {
+      server.once("error", (err: NodeJS.ErrnoException) => {
+        if (err.code === "EADDRINUSE" && attempt < PORT_RETRIES) {
+          attempt++;
+          server.removeAllListeners("error");
+          // The failed listen() left its one-shot 'listening' callback
+          // registered; drop it or every stale callback fires when a later
+          // port finally binds.
+          server.removeAllListeners("listening");
+          tryPort(candidate + 1);
+        } else {
+          reject(err);
+        }
+      });
+      server.listen(candidate, "127.0.0.1", () => {
+        const addr = server.address();
+        const bound =
+          typeof addr === "object" && addr !== null
+            ? (addr as { port: number }).port
+            : candidate;
+        server.removeAllListeners("error");
+        server.on("error", (err) =>
+          logError("gateway", "HTTP server error", err),
+        );
+        resolve(bound);
+      });
+    };
+    tryPort(port);
+  });
+}