@baique/pi-web-sky 0.1.35 → 0.1.36

package/lib/patch.test.mjs

@@ -0,0 +1,110 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+async function loadSubject() {
+  return import("./patch.ts");
+}
+
+test("parses paired changes into split diff rows", async () => {
+  const { parseUnifiedPatch } = await loadSubject();
+  const files = parseUnifiedPatch(`--- a/demo.ts
++++ b/demo.ts
+@@ -10,3 +10,3 @@
+ const keep = true;
+-const value = "old";
++const value = "new";
+ done();
+`);
+
+  assert.equal(files?.length, 1);
+  assert.equal(files?.[0].oldPath, "a/demo.ts");
+  assert.equal(files?.[0].newPath, "b/demo.ts");
+  assert.deepEqual(files?.[0].rows.filter((row) => row.type === "line"), [
+    {
+      type: "line",
+      left: { lineNo: 10, text: "const keep = true;", type: "context" },
+      right: { lineNo: 10, text: "const keep = true;", type: "context" },
+    },
+    {
+      type: "line",
+      left: { lineNo: 11, text: 'const value = "old";', type: "removed" },
+      right: { lineNo: 11, text: 'const value = "new";', type: "added" },
+    },
+    {
+      type: "line",
+      left: { lineNo: 12, text: "done();", type: "context" },
+      right: { lineNo: 12, text: "done();", type: "context" },
+    },
+  ]);
+});
+
+test("pads one-sided additions and removes timestamp suffixes from file paths", async () => {
+  const { parseUnifiedPatch } = await loadSubject();
+  const files = parseUnifiedPatch(`--- a/demo.ts\t2026-01-01
++++ b/demo.ts\t2026-01-02
+@@ -1,1 +1,2 @@
+ first
++second
+`);
+
+  assert.equal(files?.[0].oldPath, "a/demo.ts");
+  assert.equal(files?.[0].newPath, "b/demo.ts");
+  assert.deepEqual(files?.[0].rows.at(-1), {
+    type: "line",
+    left: { lineNo: null, text: "", type: "empty" },
+    right: { lineNo: 2, text: "second", type: "added" },
+  });
+});
+
+test("treats in-hunk lines that look like file headers as content", async () => {
+  const { parseUnifiedPatch } = await loadSubject();
+  // The added line's content starts with "++ " and the removed line's with
+  // "-- ", so the raw diff lines are "+++ ..." and "--- ...". They must be
+  // parsed as one file's added/removed content, not as new file headers.
+  const files = parseUnifiedPatch(`--- a/notes.md
++++ b/notes.md
+@@ -1,2 +1,2 @@
+-- old bullet
+++ new bullet
+ tail
+`);
+
+  assert.equal(files?.length, 1);
+  assert.equal(files?.[0].newPath, "b/notes.md");
+  const lines = files?.[0].rows.filter((row) => row.type === "line");
+  assert.deepEqual(lines?.[0], {
+    type: "line",
+    left: { lineNo: 1, text: "- old bullet", type: "removed" },
+    right: { lineNo: 1, text: "+ new bullet", type: "added" },
+  });
+  assert.deepEqual(lines?.[1], {
+    type: "line",
+    left: { lineNo: 2, text: "tail", type: "context" },
+    right: { lineNo: 2, text: "tail", type: "context" },
+  });
+});
+
+test("parses multiple files, resuming header detection after each hunk", async () => {
+  const { parseUnifiedPatch } = await loadSubject();
+  const files = parseUnifiedPatch(`--- a/one.ts
++++ b/one.ts
+@@ -1 +1 @@
+-a
++b
+--- a/two.ts
++++ b/two.ts
+@@ -1 +1 @@
+-c
++d
+`);
+
+  assert.equal(files?.length, 2);
+  assert.equal(files?.[0].newPath, "b/one.ts");
+  assert.equal(files?.[1].newPath, "b/two.ts");
+});
+
+test("returns null for text without diff lines", async () => {
+  const { parseUnifiedPatch } = await loadSubject();
+
+  assert.equal(parseUnifiedPatch("not a patch"), null);
+});

package/lib/patch.ts

@@ -0,0 +1,134 @@
+export type SplitDiffCellType = "context" | "removed" | "added" | "empty";
+
+export interface SplitDiffCell {
+  lineNo: number | null;
+  text: string;
+  type: SplitDiffCellType;
+}
+
+export type SplitDiffRow =
+  | { type: "hunk"; text: string }
+  | { type: "line"; left: SplitDiffCell; right: SplitDiffCell };
+
+export interface SplitDiffFile {
+  oldPath?: string;
+  newPath?: string;
+  rows: SplitDiffRow[];
+}
+
+interface PendingChangeLine {
+  lineNo: number;
+  text: string;
+}
+
+export function parseUnifiedPatch(text: string): SplitDiffFile[] | null {
+  const files: SplitDiffFile[] = [];
+  let current: SplitDiffFile | null = null;
+  let pendingOldPath: string | undefined;
+  let oldLineNo = 0;
+  let newLineNo = 0;
+  // Lines still expected in the current hunk body, from the @@ header counts.
+  // While either is positive we are inside a hunk, where a line starting with
+  // "--- "/"+++ " is a removed/added content line (e.g. "-- x"/"++ x"), not a
+  // file header — checking for headers there splits one file into bogus extras.
+  let hunkOldRemaining = 0;
+  let hunkNewRemaining = 0;
+  let removed: PendingChangeLine[] = [];
+  let added: PendingChangeLine[] = [];
+
+  const emptyCell = (): SplitDiffCell => ({ lineNo: null, text: "", type: "empty" });
+  const flushChanges = () => {
+    if (!current) {
+      removed = [];
+      added = [];
+      return;
+    }
+    const count = Math.max(removed.length, added.length);
+    for (let i = 0; i < count; i++) {
+      const left = removed[i]
+        ? { lineNo: removed[i].lineNo, text: removed[i].text, type: "removed" as const }
+        : emptyCell();
+      const right = added[i]
+        ? { lineNo: added[i].lineNo, text: added[i].text, type: "added" as const }
+        : emptyCell();
+      current.rows.push({ type: "line", left, right });
+    }
+    removed = [];
+    added = [];
+  };
+
+  for (const line of text.split(/\r?\n/)) {
+    const insideHunk = hunkOldRemaining > 0 || hunkNewRemaining > 0;
+
+    // File headers only appear between hunks, never inside a hunk body.
+    if (!insideHunk) {
+      if (line.startsWith("--- ")) {
+        flushChanges();
+        pendingOldPath = cleanPatchPath(line.slice(4));
+        continue;
+      }
+
+      if (line.startsWith("+++ ")) {
+        flushChanges();
+        current = { oldPath: pendingOldPath, newPath: cleanPatchPath(line.slice(4)), rows: [] };
+        files.push(current);
+        continue;
+      }
+    }
+
+    const hunk = line.match(/^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
+    if (hunk) {
+      if (!current) {
+        current = { rows: [] };
+        files.push(current);
+      }
+      flushChanges();
+      oldLineNo = Number(hunk[1]);
+      newLineNo = Number(hunk[3]);
+      hunkOldRemaining = hunk[2] === undefined ? 1 : Number(hunk[2]);
+      hunkNewRemaining = hunk[4] === undefined ? 1 : Number(hunk[4]);
+      current.rows.push({ type: "hunk", text: line });
+      continue;
+    }
+
+    if (!current) continue;
+
+    if (line.startsWith("\\ ")) {
+      flushChanges();
+      current.rows.push({ type: "hunk", text: line });
+      continue;
+    }
+
+    const prefix = line[0];
+    const content = line.slice(1);
+
+    if (prefix === " ") {
+      flushChanges();
+      current.rows.push({
+        type: "line",
+        left: { lineNo: oldLineNo++, text: content, type: "context" },
+        right: { lineNo: newLineNo++, text: content, type: "context" },
+      });
+      if (hunkOldRemaining > 0) hunkOldRemaining--;
+      if (hunkNewRemaining > 0) hunkNewRemaining--;
+    } else if (prefix === "-") {
+      removed.push({ lineNo: oldLineNo++, text: content });
+      if (hunkOldRemaining > 0) hunkOldRemaining--;
+    } else if (prefix === "+") {
+      added.push({ lineNo: newLineNo++, text: content });
+      if (hunkNewRemaining > 0) hunkNewRemaining--;
+    } else if (line !== "") {
+      flushChanges();
+      current.rows.push({ type: "hunk", text: line });
+    }
+  }
+
+  flushChanges();
+
+  const parsed = files.filter((file) => file.rows.some((row) => row.type === "line"));
+  return parsed.length > 0 ? parsed : null;
+}
+
+function cleanPatchPath(path: string): string {
+  return path.split("\t")[0].trim();
+}

package/lib/path-security.ts

@@ -0,0 +1,42 @@
+import { realpathSync } from "fs";
+import path from "path";
+import { isWindowsAbsolutePath } from "./paths";
+
+/**
+ * Lexical containment check. Accepts either canonical form on both sides: it
+ * re-resolves through path.win32/path.posix and case-folds on Windows, so
+ * separator style and drive-letter case never decide the answer.
+ */
+export function isPathWithinRoots(target: string, roots: Set<string>): boolean {
+  for (const root of roots) {
+    const useWindowsRules = isWindowsAbsolutePath(target) || isWindowsAbsolutePath(root);
+    const resolver = useWindowsRules ? path.win32 : path;
+    const sep = useWindowsRules ? "\\" : path.sep;
+    const normalized = resolver.resolve(target);
+    const normalizedRoot = resolver.resolve(root);
+    const comparable = useWindowsRules ? normalized.toLowerCase() : normalized;
+    const comparableRoot = useWindowsRules ? normalizedRoot.toLowerCase() : normalizedRoot;
+    const rootWithSep = comparableRoot.endsWith(sep) ? comparableRoot : comparableRoot + sep;
+    if (comparable === comparableRoot || comparable.startsWith(rootWithSep)) return true;
+  }
+  return false;
+}
+
+export function isExistingPathWithinRoots(target: string, roots: Set<string>): boolean {
+  let realTarget: string;
+  try {
+    realTarget = realpathSync(target);
+  } catch {
+    return false;
+  }
+
+  const realRoots = new Set<string>();
+  for (const root of roots) {
+    try {
+      realRoots.add(realpathSync(root));
+    } catch {
+      // Ignore stale roots derived from removed sessions or worktrees.
+    }
+  }
+  return isPathWithinRoots(realTarget, realRoots);
+}

package/lib/paths.test.mjs

@@ -0,0 +1,58 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+const isWindows = process.platform === "win32";
+
+async function loadSubject() {
+  const { createJiti } = await import("jiti");
+  return createJiti(import.meta.url).import("./paths.ts");
+}
+
+test("toNativePath converts git's POSIX output to native separators", async () => {
+  const { toNativePath } = await loadSubject();
+  if (isWindows) {
+    // The regression this guards: `git rev-parse --path-format=absolute` prints
+    // `D:/repo` on Windows, which never string-compares equal to a session cwd.
+    assert.equal(toNativePath("D:/repo/sub"), "D:\\repo\\sub");
+    assert.equal(toNativePath("D:\\repo\\sub"), "D:\\repo\\sub");
+  } else {
+    assert.equal(toNativePath("/repo/sub"), "/repo/sub");
+  }
+  assert.equal(toNativePath(""), "");
+});
+
+test("samePath ignores separator style and Windows case", async () => {
+  const { samePath } = await loadSubject();
+  assert.equal(samePath("/a/b", "/a/b"), true);
+  assert.equal(samePath("/a/b/", "/a/b"), true, "trailing separators must not matter");
+  assert.equal(samePath("/a/./b", "/a/b"), true, "dot segments must not matter");
+  assert.equal(samePath("/a/b", "/a/c"), false);
+  assert.equal(samePath("", ""), true);
+  assert.equal(samePath("", "/a"), false);
+
+  if (isWindows) {
+    assert.equal(samePath("D:/repo", "D:\\repo"), true, "separator style must not matter");
+    assert.equal(samePath("d:\\repo", "D:\\repo"), true, "drive-letter case must not matter");
+    assert.equal(samePath("D:\\Repo\\Sub", "d:/repo/sub"), true);
+    assert.equal(samePath("D:\\repo\\", "D:/repo"), true);
+    assert.equal(samePath("D:\\repo", "D:\\repo2"), false);
+  } else {
+    // POSIX is case-sensitive and backslash is a legal filename character.
+    assert.equal(samePath("/Repo", "/repo"), false);
+    assert.equal(samePath("/a\\b", "/a/b"), false);
+  }
+});
+
+test("toSlashPath normalizes to forward slashes", async () => {
+  const { toSlashPath } = await loadSubject();
+  assert.equal(toSlashPath("D:\\repo\\sub"), "D:/repo/sub");
+  assert.equal(toSlashPath("/repo/sub"), "/repo/sub");
+});
+
+test("isWindowsAbsolutePath recognizes drive and UNC paths", async () => {
+  const { isWindowsAbsolutePath } = await loadSubject();
+  assert.equal(isWindowsAbsolutePath("D:\\repo"), true);
+  assert.equal(isWindowsAbsolutePath("d:/repo"), true);
+  assert.equal(isWindowsAbsolutePath("\\\\server\\share"), true);
+  assert.equal(isWindowsAbsolutePath("relative/path"), false);
+});

package/lib/paths.ts

@@ -0,0 +1,71 @@
+import { normalize, parse, sep } from "path";
+
+// ============================================================================
+// Path primitives.
+//
+// Two canonical forms coexist deliberately — pick by where the path is going:
+//
+//   toNativePath()  Native separators (`D:\repo` on Windows). Use for anything
+//                   that reaches fs/path APIs, gets compared against a session
+//                   cwd, or is shown to the user. This is the form pi records
+//                   cwds in, so it is the default for user-facing paths.
+//
+//   toSlashPath()   Forward slashes (`D:/repo`). Use only for internal,
+//                   never-displayed bookkeeping — the allowed-roots set, and
+//                   separator-insensitive text matching. Containment checks
+//                   re-normalize their inputs anyway (see path-security.ts),
+//                   so this form is about consistent keys, not correctness.
+//
+// Comparison always goes through samePath()/isPathWithinRoots(), never `===`:
+// git emits POSIX-style paths even on Windows, and Windows itself is
+// case-insensitive, so raw string equality silently fails on both counts.
+// ============================================================================
+
+const WINDOWS_ABSOLUTE_RE = /^[a-zA-Z]:[\\/]/;
+
+export function isWindowsAbsolutePath(filePath: string): boolean {
+  return WINDOWS_ABSOLUTE_RE.test(filePath) || filePath.startsWith("\\\\") || filePath.startsWith("//");
+}
+
+/**
+ * Convert a path to native separators. Chiefly for git output: git prints
+ * POSIX-style absolute paths even on Windows (`D:/repo/sub`), which never
+ * string-compares equal to the native paths Node and pi produce.
+ *
+ * Only pass paths — a branch name like `feature/x` would become `feature\x`.
+ */
+export function toNativePath(p: string): string {
+  if (!p || process.platform !== "win32") return p;
+  return normalize(p);
+}
+
+/** Convert a path to forward slashes. See the form guidance above. */
+export function toSlashPath(p: string): string {
+  return p.replace(/\\/g, "/");
+}
+
+function normalizeForComparison(p: string): string {
+  const normalized = normalize(toNativePath(p));
+  const rootLength = parse(normalized).root.length;
+  let end = normalized.length;
+  while (end > rootLength && normalized[end - 1] === sep) end--;
+  return normalized.slice(0, end);
+}
+
+/**
+ * Whether two paths denote the same location, tolerating separator style and —
+ * on Windows, where the filesystem is case-insensitive — case, including the
+ * drive letter (`d:\repo` vs `D:\repo`).
+ *
+ * Compares lexically: callers wanting symlinks resolved should realpath first.
+ */
+export function samePath(a: string, b: string): boolean {
+  if (a === b) return true;
+  if (!a || !b) return false;
+  const normalizedA = normalizeForComparison(a);
+  const normalizedB = normalizeForComparison(b);
+  if (process.platform === "win32") {
+    return normalizedA.toLowerCase() === normalizedB.toLowerCase();
+  }
+  return normalizedA === normalizedB;
+}

package/lib/pi-types.ts

@@ -0,0 +1,183 @@
+import type {
+  AgentSessionEvent,
+  BashOperations,
+  SessionManager,
+  SettingsManager,
+  SlashCommandInfo,
+  Theme,
+} from "@earendil-works/pi-coding-agent";
+import type { AgentMessage as PiAgentMessage } from "@earendil-works/pi-agent-core";
+
+export interface ContextUsage {
+  percent: number | null;
+  contextWindow: number;
+  tokens: number | null;
+}
+
+export interface ModelLike {
+  id: string;
+  provider: string;
+}
+
+export interface ToolInfo {
+  name: string;
+  description: string;
+}
+
+export interface NavigateTreeResult {
+  editorText?: string;
+  cancelled: boolean;
+  aborted?: boolean;
+}
+
+export interface SessionStatsInfo {
+  sessionFile?: string;
+  sessionId: string;
+  sessionName?: string;
+  userMessages: number;
+  assistantMessages: number;
+  toolCalls: number;
+  toolResults: number;
+  totalMessages: number;
+  tokens: {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+    total: number;
+  };
+  cost: number;
+  contextUsage?: ContextUsage;
+  /** Estimated active time across all entries in the session file. */
+  totalActiveMs?: number;
+}
+
+interface PromptTemplateLike {
+  name: string;
+  description?: string;
+  sourceInfo: SlashCommandInfo["sourceInfo"];
+}
+
+interface SkillLike {
+  name: string;
+  description?: string;
+  sourceInfo: SlashCommandInfo["sourceInfo"];
+}
+
+interface ResourceLoaderLike {
+  getSkills(): { skills: SkillLike[] };
+}
+
+interface ExtensionRunnerLike {
+  getRegisteredCommands(): Array<{
+    invocationName: string;
+    description?: string;
+    sourceInfo: SlashCommandInfo["sourceInfo"];
+  }>;
+  emit?(event: { type: "session_shutdown"; reason: "quit" }): Promise<unknown>;
+  setUIContext?(uiContext?: unknown, mode?: "tui" | "rpc" | "json" | "print"): void;
+}
+
+type DialogOptionsLike = {
+  signal?: AbortSignal;
+  timeout?: number;
+};
+
+type WidgetOptionsLike = {
+  placement?: "aboveEditor" | "belowEditor";
+};
+
+export interface ExtensionUiContextLike {
+  select(title: string, options: string[], opts?: DialogOptionsLike): Promise<string | undefined>;
+  confirm(title: string, message: string, opts?: DialogOptionsLike): Promise<boolean>;
+  input(title: string, placeholder?: string, opts?: DialogOptionsLike): Promise<string | undefined>;
+  editor(title: string, prefill?: string, opts?: DialogOptionsLike): Promise<string | undefined>;
+  notify(message: string, type?: "info" | "warning" | "error"): void;
+  onTerminalInput(): () => void;
+  setStatus(key: string, text: string | undefined): void;
+  setWorkingMessage(message?: string): void;
+  setWorkingVisible(visible: boolean): void;
+  setWorkingIndicator(options?: { frames?: string[]; intervalMs?: number }): void;
+  setHiddenThinkingLabel(label?: string): void;
+  setWidget(key: string, content: string[] | ((...args: never[]) => unknown) | undefined, options?: WidgetOptionsLike): void;
+  setFooter(factory: unknown): void;
+  setHeader(factory: unknown): void;
+  setTitle(title: string): void;
+  custom<T = unknown>(...args: unknown[]): Promise<T>;
+  pasteToEditor(text: string): void;
+  setEditorText(text: string): void;
+  getEditorText(): string;
+  addAutocompleteProvider(): void;
+  setEditorComponent(): void;
+  getEditorComponent(): undefined;
+  readonly theme: Theme;
+  getAllThemes(): unknown[];
+  getTheme(name: string): undefined;
+  setTheme(theme: unknown): { success: boolean; error?: string };
+  getToolsExpanded(): boolean;
+  setToolsExpanded(expanded: boolean): void;
+}
+
+export interface AgentSessionLike {
+  readonly sessionId: string;
+  readonly sessionFile: string | undefined;
+  readonly isStreaming: boolean;
+  readonly isCompacting: boolean;
+  readonly autoCompactionEnabled: boolean;
+  readonly autoRetryEnabled: boolean;
+  readonly model: ModelLike | undefined;
+  readonly modelRuntime: {
+    getModel: (provider: string, modelId: string) => ModelLike | undefined;
+    refresh: (options?: { allowNetwork?: boolean }) => Promise<unknown>;
+  };
+  readonly sessionManager: SessionManager;
+  readonly settingsManager: SettingsManager;
+  readonly agent: {
+    state?: {
+      systemPrompt?: string;
+      thinkingLevel?: string;
+      streamingMessage?: PiAgentMessage;
+    };
+  };
+  readonly extensionRunner: ExtensionRunnerLike;
+  readonly promptTemplates: readonly PromptTemplateLike[];
+  readonly resourceLoader: ResourceLoaderLike;
+
+  readonly bindExtensions?: unknown;
+  dispose(): void;
+  reload(options?: { beforeSessionStart?: () => void | Promise<void> }): Promise<void>;
+  subscribe(listener: (event: AgentSessionEvent) => void): () => void;
+  prompt(text: string, options?: {
+    images?: Array<{ type: "image"; data: string; mimeType: string }>;
+    streamingBehavior?: "steer" | "followUp";
+    source?: "interactive" | "rpc";
+    preflightResult?: (success: boolean) => void;
+  }): Promise<void>;
+  abort(): Promise<void>;
+  executeBash(command: string, onChunk?: (chunk: string) => void, options?: {
+    excludeFromContext?: boolean;
+    operations?: BashOperations;
+  }): Promise<{ output: string; exitCode?: number; cancelled?: boolean; truncated?: boolean; fullOutputPath?: string }>;
+  abortBash(): void;
+  readonly isBashRunning: boolean;
+  setModel(model: ModelLike): Promise<void>;
+  navigateTree(targetId: string, options?: { summarize?: boolean }): Promise<NavigateTreeResult>;
+  setThinkingLevel(level: string): void;
+  compact(customInstructions?: string): Promise<unknown>;
+  setSessionName(name: string): void;
+  getSessionStats(): Omit<SessionStatsInfo, "sessionName">;
+  getLastAssistantText(): string | undefined;
+  setAutoCompactionEnabled(enabled: boolean): void;
+  setAutoRetryEnabled(enabled: boolean): void;
+  steer(text: string, images?: Array<{ type: "image"; data: string; mimeType: string }>): Promise<void>;
+  followUp(text: string, images?: Array<{ type: "image"; data: string; mimeType: string }>): Promise<void>;
+  readonly pendingMessageCount: number;
+  getSteeringMessages(): readonly string[];
+  getFollowUpMessages(): readonly string[];
+  clearQueue(): { steering: string[]; followUp: string[] };
+  getAllTools(): ToolInfo[];
+  getActiveToolNames(): string[];
+  setActiveToolsByName(names: string[]): void;
+  abortCompaction(): void;
+  getContextUsage(): ContextUsage | undefined;
+}

package/lib/pi-web-options.test.mjs

@@ -0,0 +1,63 @@
+import assert from "node:assert/strict";
+import { createRequire } from "node:module";
+import test from "node:test";
+
+const require = createRequire(import.meta.url);
+const { parseLaunchOptions } = require("../bin/pi-web-options.js");
+
+test("opens the browser by default", () => {
+  assert.deepEqual(parseLaunchOptions([], {}), {
+    port: "30141",
+    hostname: "127.0.0.1",
+    openBrowser: true,
+  });
+});
+
+test("supports the no-open CLI option", () => {
+  assert.equal(parseLaunchOptions(["--no-open"], {}).openBrowser, false);
+});
+
+test("supports truthy PI_WEB_NO_OPEN values", () => {
+  for (const value of ["1", "true", "TRUE", "yes", "on"]) {
+    assert.equal(parseLaunchOptions([], { PI_WEB_NO_OPEN: value }).openBrowser, false);
+  }
+});
+
+test("does not disable browser opening for false PI_WEB_NO_OPEN values", () => {
+  for (const value of ["0", "false", "off", ""]) {
+    assert.equal(parseLaunchOptions([], { PI_WEB_NO_OPEN: value }).openBrowser, true);
+  }
+});
+
+test("preserves port and hostname options", () => {
+  assert.deepEqual(
+    parseLaunchOptions(["-p", "8080", "-H", "0.0.0.0"], {}),
+    {
+      port: "8080",
+      hostname: "0.0.0.0",
+      openBrowser: true,
+    },
+  );
+});
+
+test("rejects port values that could inject cmd arguments", () => {
+  assert.throws(
+    () => parseLaunchOptions(["-p", "30141&whoami"], {}),
+    /Port must be a non-negative integer/,
+  );
+  assert.throws(
+    () => parseLaunchOptions([], { PORT: "30141&whoami" }),
+    /Port must be a non-negative integer/,
+  );
+});
+
+test("supports PI_WEB_HOSTNAME without trusting the ambient system HOSTNAME", () => {
+  assert.equal(
+    parseLaunchOptions([], { HOSTNAME: "container-id" }).hostname,
+    "127.0.0.1",
+  );
+  assert.equal(
+    parseLaunchOptions([], { PI_WEB_HOSTNAME: "0.0.0.0" }).hostname,
+    "0.0.0.0",
+  );
+});