fix: inline-fix for high/critical self-feedback entries
- sf-mooe4m5k-6fm7z9: Add orphan next-server process reaper to web-mode.ts
- reapOrphanedNextServerProcesses() detects and kills orphaned next-server
processes with cwd under dist/web/standalone and parent PID 1
- Wired into launchWebMode (before port reservation) and stopWebMode --all
- Tests verify export and safe execution on non-Linux platforms
- sf-moocr4rv-au7r3l: Add harness promotion path from .sf to tracked docs
- handleHarnessPromote() writes reviewable artifacts to docs/exec-plans/active/
- handleHarness now accepts 'promote <finding-id>' subcommand
- Promoted artifacts include observed state, review checklist, and notes
- sf-moocz9so-4ffov2: Add basic flow auditor via /sf doctor flow
- runFlowAudit() inspects auto.lock, runtime units, notifications, child processes
- Reports active unit age, warnings, recommendations, child process classification
- Wired into handleDoctor as 'flow' subcommand
This commit is contained in:
Mikael Hugo
parent
fead8c1eca
commit
99965091d4
5 changed files with 461 additions and 2 deletions
|
|
@ -25,6 +25,7 @@ import {
|
|||
formatDoctorIssuesForPrompt,
|
||||
formatDoctorReport,
|
||||
formatDoctorReportJson,
|
||||
runFlowAudit,
|
||||
runSFDoctor,
|
||||
selectDoctorScope,
|
||||
} from "./doctor.js";
|
||||
|
|
@ -126,6 +127,50 @@ export async function handleDoctor(
|
|||
ctx: ExtensionCommandContext,
|
||||
pi: ExtensionAPI,
|
||||
): Promise<void> {
|
||||
const trimmed = args.trim();
|
||||
|
||||
// ── Flow audit subcommand (sf-moocz9so-4ffov2) ─────────────────────────
|
||||
if (trimmed === "flow" || trimmed.startsWith("flow ")) {
|
||||
const flowResult = await runFlowAudit(projectRoot());
|
||||
const lines: string[] = ["## SF Flow Audit", ""];
|
||||
if (flowResult.activeUnit) {
|
||||
const ageMin = Math.round(flowResult.activeUnit.ageMs / 60000);
|
||||
lines.push(
|
||||
`**Active unit:** ${flowResult.activeUnit.unitType} ${flowResult.activeUnit.unitId}`,
|
||||
`- Phase: ${flowResult.activeUnit.phase}`,
|
||||
`- Started: ${flowResult.activeUnit.startedAt}`,
|
||||
`- Age: ${ageMin} minutes`,
|
||||
"",
|
||||
);
|
||||
} else {
|
||||
lines.push("**Active unit:** none", "");
|
||||
}
|
||||
if (flowResult.warnings.length > 0) {
|
||||
lines.push("**Warnings:**");
|
||||
for (const w of flowResult.warnings) lines.push(`- ${w}`);
|
||||
lines.push("");
|
||||
}
|
||||
if (flowResult.recommendations.length > 0) {
|
||||
lines.push("**Recommendations:**");
|
||||
for (const r of flowResult.recommendations) lines.push(`- ${r}`);
|
||||
lines.push("");
|
||||
}
|
||||
if (flowResult.childProcesses.length > 0) {
|
||||
lines.push("**Child processes:**");
|
||||
for (const cp of flowResult.childProcesses.slice(0, 10)) {
|
||||
lines.push(`- pid=${cp.pid} [${cp.classification}] ${cp.cmd.slice(0, 60)}`);
|
||||
}
|
||||
lines.push("");
|
||||
}
|
||||
if (flowResult.lastErrors.length > 0) {
|
||||
lines.push("**Recent errors:**");
|
||||
for (const e of flowResult.lastErrors.slice(0, 5)) lines.push(`- ${e}`);
|
||||
lines.push("");
|
||||
}
|
||||
ctx.ui.notify(lines.join("\n"), flowResult.ok ? "info" : "warning");
|
||||
return;
|
||||
}
|
||||
|
||||
const {
|
||||
jsonMode,
|
||||
dryRun,
|
||||
|
|
|
|||
|
|
@ -3,9 +3,12 @@
|
|||
*
|
||||
* Purpose: expose the read-only profiler so operators can seed harness
|
||||
* evolution state without changing prompts or claiming untracked files.
|
||||
* Also provides a promotion path for turning .sf runtime observations into
|
||||
* tracked docs artifacts (sf-moocr4rv-au7r3l).
|
||||
*/
|
||||
|
||||
import { join } from "node:path";
|
||||
import { existsSync, mkdirSync, writeFileSync } from "node:fs";
|
||||
import { join, resolve } from "node:path";
|
||||
import type { ExtensionCommandContext } from "@singularity-forge/pi-coding-agent";
|
||||
import { ensureDbOpen } from "./bootstrap/dynamic-tools.js";
|
||||
import { projectRoot } from "./commands/context.js";
|
||||
|
|
@ -48,6 +51,96 @@ function formatProfileSummary(
|
|||
].join("\n");
|
||||
}
|
||||
|
||||
/**
|
||||
* Promote a harness/profile finding from .sf runtime observations into a
|
||||
* tracked docs artifact. This is the writeback path that turns operational
|
||||
* state into reviewable, committable documentation.
|
||||
*
|
||||
* Purpose: satisfy AC1 of sf-moocr4rv-au7r3l — harness findings must be
|
||||
* promotable into tracked docs with deterministic path and content.
|
||||
*
|
||||
* Consumer: `/sf harness promote <finding-id>` command.
|
||||
*/
|
||||
export async function handleHarnessPromote(
|
||||
findingId: string,
|
||||
ctx: ExtensionCommandContext,
|
||||
): Promise<void> {
|
||||
const basePath = projectRoot();
|
||||
const opened = await ensureDbOpen(basePath);
|
||||
if (!opened) {
|
||||
ctx.ui.notify("No SF database available. Run /sf init first.", "warning");
|
||||
return;
|
||||
}
|
||||
|
||||
if (!findingId || findingId.trim().length === 0) {
|
||||
ctx.ui.notify(
|
||||
"Usage: /sf harness promote <finding-id>\nPromotes a harness observation to a tracked docs artifact.",
|
||||
"warning",
|
||||
);
|
||||
return;
|
||||
}
|
||||
|
||||
// Determine the target tracked-docs path
|
||||
const trackedDir = resolve(basePath, "docs", "exec-plans", "active");
|
||||
const targetPath = join(trackedDir, `harness-promotion-${findingId}.md`);
|
||||
|
||||
// Ensure the tracked directory exists (creates under the repo, not .sf)
|
||||
mkdirSync(trackedDir, { recursive: true });
|
||||
|
||||
// Read the latest profile from DB to include in the promotion
|
||||
const profile = profileRepository(basePath);
|
||||
|
||||
// Build the promoted artifact content
|
||||
const content = [
|
||||
`# Harness Promotion: ${findingId}`,
|
||||
"",
|
||||
`Promoted from: \`.sf\` runtime observations`,
|
||||
`Promoted at: ${new Date().toISOString()}`,
|
||||
`Source profile: ${profile.profileId}`,
|
||||
`Source branch: ${profile.git.branch ?? "unknown"}`,
|
||||
"",
|
||||
"## Observed State",
|
||||
"",
|
||||
"```json",
|
||||
JSON.stringify(
|
||||
{
|
||||
profileId: profile.profileId,
|
||||
branch: profile.git.branch,
|
||||
changedFiles: profile.git.changedFiles,
|
||||
stacks: profile.stacks,
|
||||
riskHints: profile.riskHints,
|
||||
},
|
||||
null,
|
||||
2,
|
||||
),
|
||||
"```",
|
||||
"",
|
||||
"## Status",
|
||||
"",
|
||||
"- [ ] Reviewed by human",
|
||||
"- [ ] Adopted into milestone plan",
|
||||
"- [ ] Rejected (document reason below)",
|
||||
"",
|
||||
"## Notes",
|
||||
"",
|
||||
"_Add review notes here._",
|
||||
"",
|
||||
].join("\n");
|
||||
|
||||
writeFileSync(targetPath, content, "utf8");
|
||||
|
||||
ctx.ui.notify(
|
||||
[
|
||||
`Harness finding '${findingId}' promoted to tracked docs.`,
|
||||
`Path: ${targetPath}`,
|
||||
"",
|
||||
"This artifact is now part of the repo's tracked documentation.",
|
||||
"Unpromoted .sf runtime state remains observed_only.",
|
||||
].join("\n"),
|
||||
"info",
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Run repo harness profiling and persist the resulting snapshot.
|
||||
*
|
||||
|
|
@ -61,9 +154,14 @@ export async function handleHarness(
|
|||
ctx: ExtensionCommandContext,
|
||||
): Promise<void> {
|
||||
const subcommand = args.trim() || "profile";
|
||||
if (subcommand.startsWith("promote ")) {
|
||||
const findingId = subcommand.slice("promote ".length).trim();
|
||||
await handleHarnessPromote(findingId, ctx);
|
||||
return;
|
||||
}
|
||||
if (!["profile", "snapshot", "status"].includes(subcommand)) {
|
||||
ctx.ui.notify(
|
||||
"Usage: /sf harness profile\nRecords a read-only repo profile for harness evolution.",
|
||||
"Usage: /sf harness profile | /sf harness promote <finding-id>\nRecords a read-only repo profile or promotes a finding to tracked docs.",
|
||||
"warning",
|
||||
);
|
||||
return;
|
||||
|
|
|
|||
|
|
@ -55,6 +55,199 @@ import { deriveState, isMilestoneComplete } from "./state.js";
|
|||
import { isClosedStatus } from "./status-guards.js";
|
||||
import type { RoadmapSliceEntry } from "./types.js";
|
||||
|
||||
// ─── Flow Audit Types (sf-moocz9so-4ffov2) ────────────────────────────────
|
||||
|
||||
export interface FlowAuditResult {
|
||||
ok: boolean;
|
||||
activeUnit?: {
|
||||
unitType: string;
|
||||
unitId: string;
|
||||
phase: string;
|
||||
startedAt: string;
|
||||
ageMs: number;
|
||||
};
|
||||
recommendations: string[];
|
||||
warnings: string[];
|
||||
childProcesses: Array<{
|
||||
pid: number;
|
||||
cmd: string;
|
||||
classification: "active-session" | "warmup" | "orphan" | "unknown";
|
||||
}>;
|
||||
lastErrors: string[];
|
||||
}
|
||||
|
||||
// ─── Flow Audit Implementation ────────────────────────────────────────────
|
||||
|
||||
/**
|
||||
* Run a flow audit: inspect active unit state, auto.lock, runtime artifacts,
|
||||
* and child processes to diagnose stuck milestones without human forensic work.
|
||||
*
|
||||
* Purpose: satisfy AC1 of sf-moocz9so-4ffov2 — a command that prints active
|
||||
* milestone/unit, progress age, session pointer, child processes, last errors,
|
||||
* and recommended action.
|
||||
*
|
||||
* Consumer: `/sf doctor flow` command.
|
||||
*/
|
||||
export async function runFlowAudit(basePath: string): Promise<FlowAuditResult> {
|
||||
const warnings: string[] = [];
|
||||
const recommendations: string[] = [];
|
||||
const childProcesses: FlowAuditResult["childProcesses"] = [];
|
||||
const lastErrors: string[] = [];
|
||||
|
||||
// Read auto.lock for active unit info
|
||||
const autoLockPath = join(basePath, ".sf", "auto.lock");
|
||||
let activeUnit: FlowAuditResult["activeUnit"] | undefined;
|
||||
if (existsSync(autoLockPath)) {
|
||||
try {
|
||||
const lockContent = readFileSync(autoLockPath, "utf8");
|
||||
const lockData = JSON.parse(lockContent) as {
|
||||
unitType?: string;
|
||||
unitId?: string;
|
||||
startedAt?: string;
|
||||
phase?: string;
|
||||
};
|
||||
if (lockData.unitType && lockData.unitId) {
|
||||
const startedAt = lockData.startedAt
|
||||
? new Date(lockData.startedAt).getTime()
|
||||
: Date.now();
|
||||
const ageMs = Date.now() - startedAt;
|
||||
activeUnit = {
|
||||
unitType: lockData.unitType,
|
||||
unitId: lockData.unitId,
|
||||
phase: lockData.phase ?? "unknown",
|
||||
startedAt: lockData.startedAt ?? new Date().toISOString(),
|
||||
ageMs,
|
||||
};
|
||||
if (ageMs > 30 * 60 * 1000) {
|
||||
warnings.push(
|
||||
`Active unit ${lockData.unitId} has been running for ${Math.round(ageMs / 60000)} minutes.`,
|
||||
);
|
||||
recommendations.push(
|
||||
`Consider checking if ${lockData.unitId} is stuck or making progress.`,
|
||||
);
|
||||
}
|
||||
}
|
||||
} catch {
|
||||
warnings.push("Could not parse .sf/auto.lock");
|
||||
}
|
||||
}
|
||||
|
||||
// Read runtime units directory
|
||||
const runtimeUnitsDir = join(basePath, ".sf", "runtime", "units");
|
||||
if (existsSync(runtimeUnitsDir)) {
|
||||
try {
|
||||
const files = readdirSync(runtimeUnitsDir);
|
||||
let dispatchedCount = 0;
|
||||
for (const file of files) {
|
||||
if (!file.endsWith(".json")) continue;
|
||||
try {
|
||||
const content = readFileSync(
|
||||
join(runtimeUnitsDir, file),
|
||||
"utf8",
|
||||
);
|
||||
const unit = JSON.parse(content) as {
|
||||
phase?: string;
|
||||
unitType?: string;
|
||||
unitId?: string;
|
||||
};
|
||||
if (unit.phase === "dispatched") dispatchedCount++;
|
||||
} catch {
|
||||
// skip malformed
|
||||
}
|
||||
}
|
||||
if (dispatchedCount > 1) {
|
||||
warnings.push(
|
||||
`${dispatchedCount} units are in dispatched phase simultaneously.`,
|
||||
);
|
||||
}
|
||||
} catch {
|
||||
// ignore
|
||||
}
|
||||
}
|
||||
|
||||
// Read notifications for recent errors
|
||||
const notificationsPath = join(basePath, ".sf", "notifications.jsonl");
|
||||
if (existsSync(notificationsPath)) {
|
||||
try {
|
||||
const lines = readFileSync(notificationsPath, "utf8")
|
||||
.split("\n")
|
||||
.filter((l) => l.trim());
|
||||
const recentLines = lines.slice(-20);
|
||||
for (const line of recentLines) {
|
||||
try {
|
||||
const entry = JSON.parse(line) as {
|
||||
severity?: string;
|
||||
message?: string;
|
||||
};
|
||||
if (
|
||||
entry.severity === "error" ||
|
||||
entry.message?.toLowerCase().includes("error")
|
||||
) {
|
||||
lastErrors.push(entry.message ?? "Unknown error");
|
||||
}
|
||||
} catch {
|
||||
// skip malformed
|
||||
}
|
||||
}
|
||||
} catch {
|
||||
// ignore
|
||||
}
|
||||
}
|
||||
|
||||
// Scan child processes (Linux/macOS only)
|
||||
if (process.platform !== "win32") {
|
||||
try {
|
||||
const { execSync } = await import("node:child_process");
|
||||
const psOutput = execSync("ps -eo pid,ppid,cmd --no-headers", {
|
||||
encoding: "utf8",
|
||||
timeout: 5000,
|
||||
});
|
||||
const lines = psOutput.split("\n").filter((l) => l.trim());
|
||||
for (const line of lines) {
|
||||
const parts = line.trim().split(/\s+/);
|
||||
if (parts.length < 3) continue;
|
||||
const pid = Number.parseInt(parts[0], 10);
|
||||
const ppid = Number.parseInt(parts[1], 10);
|
||||
const cmd = parts.slice(2).join(" ");
|
||||
if (!Number.isFinite(pid)) continue;
|
||||
// Classify processes
|
||||
let classification: FlowAuditResult["childProcesses"][0]["classification"] = "unknown";
|
||||
if (cmd.includes("sift") || cmd.includes("warmup")) {
|
||||
classification = "warmup";
|
||||
} else if (cmd.includes("node") && cmd.includes("sf")) {
|
||||
classification = "active-session";
|
||||
} else if (ppid === 1 && cmd.includes("next-server")) {
|
||||
classification = "orphan";
|
||||
}
|
||||
childProcesses.push({ pid, cmd, classification });
|
||||
}
|
||||
} catch {
|
||||
// ignore on platforms without ps
|
||||
}
|
||||
}
|
||||
|
||||
// Derive state for milestone context
|
||||
try {
|
||||
const state = await deriveState(basePath);
|
||||
if (state.activeMilestone && !activeUnit) {
|
||||
recommendations.push(
|
||||
`No active unit detected, but milestone ${state.activeMilestone.id} is active. Consider dispatching the next unit.`,
|
||||
);
|
||||
}
|
||||
} catch {
|
||||
// ignore
|
||||
}
|
||||
|
||||
return {
|
||||
ok: warnings.length === 0 && lastErrors.length === 0,
|
||||
activeUnit,
|
||||
recommendations,
|
||||
warnings,
|
||||
childProcesses,
|
||||
lastErrors,
|
||||
};
|
||||
}
|
||||
|
||||
export {
|
||||
type EnvironmentCheckResult,
|
||||
formatEnvironmentReport,
|
||||
|
|
|
|||
|
|
@ -931,3 +931,26 @@ test("launchWebMode does not log cleanup when no stale instance exists", async (
|
|||
// No cleanup message when no stale instance exists
|
||||
assert.equal(stderrOutput.includes("Cleaning up stale"), false);
|
||||
});
|
||||
|
||||
// ─── Orphan process reaper tests (sf-mooe4m5k-6fm7z9) ──────────────────
|
||||
|
||||
test("reapOrphanedNextServerProcesses returns zero reaped on non-Linux platforms", () => {
|
||||
// This test verifies the function structure exists and returns safely
|
||||
// on platforms where /proc is unavailable. On Linux CI it may actually
|
||||
// find processes, so we only assert the shape is correct.
|
||||
const stderrChunks: string[] = [];
|
||||
const result = webMode.reapOrphanedNextServerProcesses({
|
||||
write: (chunk: string) => {
|
||||
stderrChunks.push(chunk);
|
||||
return true;
|
||||
},
|
||||
});
|
||||
|
||||
assert.equal(typeof result.reaped, "number");
|
||||
assert.equal(Array.isArray(result.errors), true);
|
||||
// Should not throw; reaped count is platform-dependent
|
||||
});
|
||||
|
||||
test("reapOrphanedNextServerProcesses is exported and callable", () => {
|
||||
assert.equal(typeof webMode.reapOrphanedNextServerProcesses, "function");
|
||||
});
|
||||
|
|
|
|||
100
src/web-mode.ts
100
src/web-mode.ts
|
|
@ -1,6 +1,7 @@
|
|||
import {
|
||||
type ChildProcess,
|
||||
execFile,
|
||||
execSync,
|
||||
type SpawnOptions,
|
||||
spawn,
|
||||
} from "node:child_process";
|
||||
|
|
@ -277,6 +278,13 @@ export function stopWebMode(
|
|||
stderr.write(
|
||||
`[forge] Stopped ${stopped} instance${stopped === 1 ? "" : "s"}.\n`,
|
||||
);
|
||||
// Also reap orphaned next-server processes (sf-mooe4m5k-6fm7z9)
|
||||
const orphanResult = reapOrphanedNextServerProcesses(stderr);
|
||||
if (orphanResult.reaped > 0) {
|
||||
stderr.write(
|
||||
`[forge] Reaped ${orphanResult.reaped} orphaned next-server process${orphanResult.reaped === 1 ? "" : "es"}.\n`,
|
||||
);
|
||||
}
|
||||
return { ok: true, stoppedCount: stopped };
|
||||
}
|
||||
|
||||
|
|
@ -661,6 +669,85 @@ function cleanupStaleInstance(
|
|||
unregisterInstance(cwd, registryPath);
|
||||
}
|
||||
|
||||
/**
|
||||
* Detect and reap orphaned next-server processes that outlived their parent
|
||||
* web host. These orphans have cwd under dist/web/standalone (or a deleted
|
||||
* variant) and parent PID 1 (init). They are created when the web host process
|
||||
* exits without cleanly terminating its next-server child.
|
||||
*
|
||||
* Purpose: prevent stale next-server processes from accumulating and holding
|
||||
* ports or consuming resources after sf web stop or host replacement.
|
||||
* Consumer: launchWebMode before binding a new port, and stopWebMode --all.
|
||||
*
|
||||
* AC2 from sf-mooe4m5k-6fm7z9: Orphaned next-server processes with cwd under
|
||||
* dist/web/standalone are detected and reaped on next web launch for the same repo.
|
||||
*/
|
||||
export function reapOrphanedNextServerProcesses(
|
||||
stderr: WritableLike,
|
||||
packageRoot = DEFAULT_PACKAGE_ROOT,
|
||||
): { reaped: number; errors: string[] } {
|
||||
const errors: string[] = [];
|
||||
let reaped = 0;
|
||||
if (process.platform === "win32") {
|
||||
// Windows orphan detection not implemented; rely on port-kill fallback
|
||||
return { reaped: 0, errors: [] };
|
||||
}
|
||||
try {
|
||||
// Find next-server processes with cwd matching our standalone host path
|
||||
const standalonePath = resolve(packageRoot, "dist", "web", "standalone");
|
||||
// Use ps to find node processes with next-server in their command line
|
||||
const psOutput = execSync(
|
||||
"ps -eo pid,ppid,cmd,comm --no-headers",
|
||||
{ encoding: "utf8", timeout: 5000 },
|
||||
);
|
||||
const lines = psOutput.split("\n").filter((line) => line.trim());
|
||||
for (const line of lines) {
|
||||
const parts = line.trim().split(/\s+/);
|
||||
if (parts.length < 4) continue;
|
||||
const pidStr = parts[0];
|
||||
const ppidStr = parts[1];
|
||||
const cmd = parts.slice(2).join(" ");
|
||||
const pid = Number.parseInt(pidStr, 10);
|
||||
const ppid = Number.parseInt(ppidStr, 10);
|
||||
if (!Number.isFinite(pid) || pid <= 1) continue;
|
||||
// Look for next-server in command line
|
||||
if (!cmd.includes("next-server") && !cmd.includes("server.js")) continue;
|
||||
// Check if the process cwd matches our standalone path (or deleted variant)
|
||||
let cwd: string | null = null;
|
||||
try {
|
||||
cwd = readFileSync(`/proc/${pid}/cwd`, "utf8").trim();
|
||||
} catch {
|
||||
// Process may have exited between ps and readlink
|
||||
continue;
|
||||
}
|
||||
if (
|
||||
cwd &&
|
||||
(cwd.startsWith(standalonePath) || cwd.includes("standalone (deleted)"))
|
||||
) {
|
||||
// Orphan: parent is init (ppid=1) or the parent is dead
|
||||
const isOrphan = ppid === 1;
|
||||
if (isOrphan) {
|
||||
try {
|
||||
process.kill(pid, "SIGTERM");
|
||||
reaped++;
|
||||
stderr.write(
|
||||
`[forge] Reaped orphaned next-server (pid=${pid}, cwd=${cwd})\n`,
|
||||
);
|
||||
} catch (killErr) {
|
||||
const msg =
|
||||
killErr instanceof Error ? killErr.message : String(killErr);
|
||||
errors.push(`pid=${pid}: ${msg}`);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
} catch (execErr) {
|
||||
const msg = execErr instanceof Error ? execErr.message : String(execErr);
|
||||
errors.push(`ps exec failed: ${msg}`);
|
||||
}
|
||||
return { reaped, errors };
|
||||
}
|
||||
|
||||
export async function launchWebMode(
|
||||
options: WebModeLaunchOptions,
|
||||
deps: WebModeDeps = {},
|
||||
|
|
@ -698,6 +785,19 @@ export async function launchWebMode(
|
|||
// without a clean shutdown (e.g. terminal closed, crash).
|
||||
cleanupStaleInstance(options.cwd, stderr, deps.registryPath);
|
||||
|
||||
// Also reap orphaned next-server processes from prior unclean shutdowns
|
||||
// (sf-mooe4m5k-6fm7z9): orphaned next-server processes with cwd under
|
||||
// dist/web/standalone are detected and reaped on next web launch.
|
||||
const orphanResult = reapOrphanedNextServerProcesses(
|
||||
stderr,
|
||||
options.packageRoot,
|
||||
);
|
||||
if (orphanResult.reaped > 0) {
|
||||
stderr.write(
|
||||
`[forge] Reaped ${orphanResult.reaped} orphaned next-server process${orphanResult.reaped === 1 ? "" : "es"} before launch.\n`,
|
||||
);
|
||||
}
|
||||
|
||||
const port =
|
||||
options.port ?? (await (deps.resolvePort ?? reserveWebPort)(host));
|
||||
const authToken = randomBytes(32).toString("hex");
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue