@wlv-zedd/dsh-chatgpt-web 1.0.0

package/src/doctor.ts

@@ -0,0 +1,237 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import type { AppConfig } from "./config";
+import { getConfigDir, getConfigPath, loadConfig } from "./config";
+import { join } from "node:path";
+import { inspectCodexIntegration } from "./codex-integration";
+import { browserLoginStateExists, loginVerificationMarkerPath } from "./browser-login";
+import { getServiceStatus } from "./service";
+import { tunnelStatus } from "./tunnel";
+import { getTunnelServiceStatus } from "./tunnel-service";
+import {
+  inspectLauncherBrowserHost,
+  inspectLauncherBrowserHostLiveness,
+  readLauncherBrowserHostDescriptor,
+} from "./launcher-browser-host";
+import { processRunning } from "./process";
+
+export type CheckStatus = "ok" | "warning" | "error";
+
+export interface DoctorCheck {
+  id: string;
+  status: CheckStatus;
+  message: string;
+  detail?: string;
+}
+
+export interface DoctorReport {
+  ok: boolean;
+  mode?: AppConfig["mode"];
+  checks: DoctorCheck[];
+}
+
+function secureFile(path: string): boolean {
+  if (process.platform === "win32") return true;
+  return (statSync(path).mode & 0o077) === 0;
+}
+
+function launcherOwnershipError(config: AppConfig, health: Record<string, unknown>): string | undefined {
+  if (config.browserHost !== "launcher") return undefined;
+  const path = join(getConfigDir(), "runtime", "launcher-supervisor.json");
+  if (!existsSync(path)) return `Launcher runtime ownership marker is missing: ${path}`;
+  let state: Record<string, unknown>;
+  try {
+    state = JSON.parse(readFileSync(path, "utf8")) as Record<string, unknown>;
+  } catch (error) {
+    return `Launcher runtime ownership marker is invalid: ${error instanceof Error ? error.message : String(error)}`;
+  }
+  if (state.version !== 1
+    || !Number.isInteger(state.ownerPid)
+    || (state.ownerPid as number) < 1
+    || !Number.isInteger(state.daemonPid)
+    || (state.daemonPid as number) < 1
+    || state.status !== "ready") {
+    return "Launcher runtime ownership marker is incomplete or not ready";
+  }
+  if (!processRunning(state.ownerPid)) {
+    return `Launcher owner process is not running (pid ${String(state.ownerPid)})`;
+  }
+  if (health.pid !== state.daemonPid) {
+    return `Responses proxy pid ${String(health.pid)} does not match launcher-owned pid ${String(state.daemonPid)}`;
+  }
+  return undefined;
+}
+
+async function proxyCheck(config: AppConfig): Promise<DoctorCheck> {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), 2_000);
+  try {
+    const response = await fetch(`http://${config.host}:${config.port}/healthz`, { signal: controller.signal });
+    if (!response.ok) return { id: "proxy", status: "error", message: `Responses proxy returned HTTP ${response.status}` };
+    const body = await response.json() as Record<string, unknown>;
+    if ((body.service !== "dsh-chatgpt-web" && body.service !== "codex-chatgpt-web") || body.status !== "ok") {
+      return { id: "proxy", status: "error", message: "The configured port belongs to another service" };
+    }
+    if (body.mode !== config.mode) {
+      return { id: "proxy", status: "error", message: `Daemon is running in ${String(body.mode)} mode; config requires ${config.mode}` };
+    }
+    if (body.version !== config.releaseVersion) {
+      return { id: "proxy", status: "error", message: `Daemon version is ${String(body.version)}; config requires ${config.releaseVersion}` };
+    }
+    if (body.accepting_turns !== true) {
+      return {
+        id: "proxy",
+        status: "error",
+        message: "Responses proxy is still drained and is not accepting Codex turns",
+      };
+    }
+    const ownershipError = launcherOwnershipError(config, body);
+    if (ownershipError) {
+      return { id: "proxy", status: "error", message: "Responses proxy ownership could not be verified", detail: ownershipError };
+    }
+    return { id: "proxy", status: "ok", message: `Responses proxy is healthy on 127.0.0.1:${config.port}` };
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    return { id: "proxy", status: "error", message: "Responses proxy is not reachable", detail };
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+export async function runDoctor(): Promise<DoctorReport> {
+  const checks: DoctorCheck[] = [];
+  let config: AppConfig;
+  try {
+    config = loadConfig();
+    checks.push({ id: "config", status: "ok", message: `Configuration is valid (${getConfigPath()})` });
+  } catch (error) {
+    checks.push({ id: "config", status: "error", message: "Configuration is invalid", detail: error instanceof Error ? error.message : String(error) });
+    return { ok: false, checks };
+  }
+
+  if (config.browserHost === "launcher") {
+    try {
+      const descriptor = config.browserInteractionMode === "manual"
+        ? await inspectLauncherBrowserHostLiveness(config.browserHostDescriptorPath!, { timeoutMs: 5_000 })
+        : readLauncherBrowserHostDescriptor(config.browserHostDescriptorPath!);
+      if (config.browserInteractionMode === "automatic") {
+        await inspectLauncherBrowserHost(config.browserHostDescriptorPath!, { timeoutMs: 30_000 });
+      }
+      checks.push({
+        id: "browser-host",
+        status: "ok",
+        message: config.browserInteractionMode === "manual"
+          ? `Embedded launcher browser is reachable for Zero Risk (pid ${descriptor.pid})`
+          : `Embedded launcher browser is authenticated and reachable (pid ${descriptor.pid})`,
+      });
+    } catch (error) {
+      checks.push({
+        id: "browser-host",
+        status: "error",
+        message: "Embedded launcher browser is unavailable",
+        detail: error instanceof Error ? error.message : String(error),
+      });
+    }
+  } else {
+    if (!existsSync(config.chromeExecutablePath)) {
+      checks.push({ id: "chrome", status: "error", message: `Chrome executable is missing: ${config.chromeExecutablePath}` });
+    } else {
+      checks.push({ id: "chrome", status: "ok", message: `Chrome executable found: ${config.chromeExecutablePath}` });
+    }
+    if (!browserLoginStateExists(config)) {
+      checks.push({ id: "login", status: "error", message: "ChatGPT login state is missing or unverified; run `dsh-chatgpt-web login`" });
+    } else if (!secureFile(config.storageStatePath)) {
+      checks.push({ id: "login", status: "error", message: `ChatGPT login state is readable by other users: ${config.storageStatePath}` });
+    } else if (!secureFile(loginVerificationMarkerPath(config.storageStatePath))) {
+      checks.push({ id: "login", status: "error", message: "ChatGPT login verification marker is readable by other users" });
+    } else {
+      checks.push({ id: "login", status: "ok", message: "ChatGPT login state has authenticated browser evidence" });
+    }
+  }
+
+  const codex = inspectCodexIntegration();
+  if (!codex.installed) {
+    checks.push({ id: "codex", status: "error", message: "Codex model route is not installed" });
+  } else if (codex.errors.length > 0) {
+    checks.push({ id: "codex", status: "error", message: "Codex integration is inconsistent", detail: codex.errors.join("; ") });
+  } else {
+    checks.push({ id: "codex", status: "ok", message: "Codex native model route is installed" });
+  }
+
+  const service = getServiceStatus();
+  if (config.browserHost === "launcher") {
+    checks.push(service.installed || service.loaded
+      ? {
+          id: "service",
+          status: "warning",
+          message: "A legacy OS background service still exists; rerun launcher setup to migrate ownership",
+          detail: JSON.stringify(service),
+        }
+      : { id: "service", status: "ok", message: "Launcher owns the background runtime" });
+  } else if (!service.supported) {
+    checks.push({ id: "service", status: "warning", message: "Managed service is unavailable on this OS; keep `serve` running manually" });
+  } else if (!service.installed || !service.loaded) {
+    checks.push({ id: "service", status: "error", message: "macOS background service is not installed and loaded" });
+  } else {
+    checks.push({ id: "service", status: "ok", message: "macOS background service is loaded" });
+  }
+  checks.push(await proxyCheck(config));
+
+  if (config.mode === "full") {
+    const settings = config.tunnel!;
+    if (!existsSync(settings.binaryPath)) {
+      checks.push({ id: "tunnel-binary", status: "error", message: `tunnel-client is missing: ${settings.binaryPath}` });
+    } else {
+      checks.push({ id: "tunnel-binary", status: "ok", message: "Pinned openai/tunnel-client binary is installed" });
+    }
+    if (!existsSync(settings.runtimeKeyFile)) {
+      checks.push({ id: "tunnel-key", status: "error", message: "Tunnel runtime key file is missing" });
+    } else if (!secureFile(settings.runtimeKeyFile)) {
+      checks.push({ id: "tunnel-key", status: "error", message: "Tunnel runtime key file has unsafe permissions" });
+    } else {
+      checks.push({ id: "tunnel-key", status: "ok", message: "Tunnel runtime key is stored privately" });
+    }
+    const tunnelService = getTunnelServiceStatus();
+    if (config.browserHost === "launcher") {
+      checks.push(tunnelService.installed || tunnelService.loaded
+        ? {
+            id: "tunnel-service",
+            status: "warning",
+            message: "A legacy OS tunnel service still exists; rerun launcher MCP setup to migrate ownership",
+            detail: JSON.stringify(tunnelService),
+          }
+        : { id: "tunnel-service", status: "ok", message: "Launcher owns the tunnel runtime" });
+    } else {
+      checks.push(tunnelService.installed && tunnelService.loaded && tunnelService.running
+        ? { id: "tunnel-service", status: "ok", message: "macOS tunnel service is installed, loaded, and running" }
+        : { id: "tunnel-service", status: "error", message: "macOS tunnel service is not fully running", detail: JSON.stringify(tunnelService) });
+    }
+    const runtime = tunnelStatus(config);
+    checks.push(runtime.ok
+      ? { id: "tunnel-runtime", status: "ok", message: "Tunnel runtime reports healthy and ready" }
+      : { id: "tunnel-runtime", status: "error", message: "Tunnel runtime is not ready", detail: runtime.detail });
+    checks.push({
+      id: "connector",
+      status: "warning",
+      message: `Local checks cannot prove that ChatGPT connector ${JSON.stringify(config.appName)} is attached to this tunnel`,
+      detail: "Verify it once at https://chatgpt.com/#settings/Plugins while the tunnel is ready.",
+    });
+  } else {
+    checks.push({ id: "tools", status: "warning", message: "Browser-only mode intentionally has no local tools or MCP tunnel" });
+  }
+
+  return {
+    ok: !checks.some(check => check.status === "error"),
+    mode: config.mode,
+    checks,
+  };
+}
+
+export function formatDoctorReport(report: DoctorReport): string {
+  const icon: Record<CheckStatus, string> = { ok: "✓", warning: "!", error: "✗" };
+  const lines = report.checks.flatMap(check => [
+    `${icon[check.status]} ${check.message}`,
+    ...(check.detail ? [`  ${check.detail}`] : []),
+  ]);
+  lines.push(report.ok ? "Doctor result: ready" : "Doctor result: not ready");
+  return `${lines.join("\n")}\n`;
+}

package/src/event-queue.ts

@@ -0,0 +1,45 @@
+export class AsyncEventQueue<T> implements AsyncIterable<T> {
+  private readonly buffered: T[] = [];
+  private readonly waiters: Array<(result: IteratorResult<T>) => void> = [];
+  private closed = false;
+
+  constructor(private readonly maxBuffered = 10_000) {}
+
+  push(value: T): void {
+    if (this.closed) return;
+    const waiter = this.waiters.shift();
+    if (waiter) {
+      waiter({ value, done: false });
+      return;
+    }
+    if (this.buffered.length >= this.maxBuffered) throw new Error("Adapter event backlog exceeded");
+    this.buffered.push(value);
+  }
+
+  close(): void {
+    if (this.closed) return;
+    this.closed = true;
+    while (this.waiters.length > 0) this.waiters.shift()!({ value: undefined, done: true });
+  }
+
+  async collect(): Promise<T[]> {
+    const values: T[] = [];
+    for await (const value of this) values.push(value);
+    return values;
+  }
+
+  [Symbol.asyncIterator](): AsyncIterator<T> {
+    return {
+      next: () => {
+        const value = this.buffered.shift();
+        if (value !== undefined) return Promise.resolve({ value, done: false });
+        if (this.closed) return Promise.resolve({ value: undefined, done: true });
+        return new Promise(resolve => this.waiters.push(resolve));
+      },
+      return: () => {
+        this.close();
+        return Promise.resolve({ value: undefined, done: true });
+      },
+    };
+  }
+}

package/src/http-body.ts

@@ -0,0 +1,30 @@
+const MAX_ENCODED_REQUEST_BYTES = 64 * 1024 * 1024;
+const MAX_DECODED_REQUEST_BYTES = 128 * 1024 * 1024;
+
+function assertWithinLimit(bytes: number, limit: number, label: string): void {
+  if (bytes > limit) throw new Error(`${label} exceeds ${limit} bytes`);
+}
+
+export async function readJsonRequestBody(request: Request): Promise<unknown> {
+  const declaredLength = Number(request.headers.get("content-length"));
+  if (Number.isFinite(declaredLength)) {
+    assertWithinLimit(declaredLength, MAX_ENCODED_REQUEST_BYTES, "Encoded request body");
+  }
+
+  const encoded = new Uint8Array(await request.arrayBuffer());
+  assertWithinLimit(encoded.byteLength, MAX_ENCODED_REQUEST_BYTES, "Encoded request body");
+
+  const contentEncoding = (request.headers.get("content-encoding") ?? "identity").trim().toLowerCase();
+  let decoded: Uint8Array;
+  if (contentEncoding === "" || contentEncoding === "identity") {
+    decoded = encoded;
+  } else if (contentEncoding === "zstd") {
+    decoded = await Bun.zstdDecompress(encoded);
+  } else {
+    throw new Error(`Unsupported Content-Encoding: ${contentEncoding}`);
+  }
+  assertWithinLimit(decoded.byteLength, MAX_DECODED_REQUEST_BYTES, "Decoded request body");
+
+  const text = new TextDecoder("utf-8", { fatal: true }).decode(decoded);
+  return JSON.parse(text) as unknown;
+}