@wlv-zedd/dsh-chatgpt-web 1.0.0

package/src/dev-chat/profile.ts

@@ -0,0 +1,223 @@
+import { execFileSync, spawn } from "node:child_process";
+import { readFileSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { isAbsolute, join, posix, resolve, win32 } from "node:path";
+import { expandUserPath, getConfigPath } from "../config";
+import {
+  readLauncherBrowserHostDescriptor,
+  type LauncherBrowserHostDescriptor,
+} from "../launcher-browser-host";
+
+import { DEV_LAUNCHER_PROFILE } from "./constants";
+
+export interface DevProfilePaths {
+  home: string;
+  codexHome: string;
+  launcherUserData: string;
+  launcherStatePath: string;
+  descriptorPath: string;
+  chatsPath: string;
+  runtimePath: string;
+  configPath: string;
+}
+
+const WINDOWS_LAUNCHER_GUID = "d1a6026a-6210-588e-9a2b-da3936f94e02";
+
+function registeredWindowsLauncherInstallLocation(): string | undefined {
+  try {
+    const output = execFileSync(
+      "reg.exe",
+      ["query", `HKCU\\Software\\${WINDOWS_LAUNCHER_GUID}`, "/v", "InstallLocation"],
+      { encoding: "utf8", windowsHide: true },
+    );
+    const match = output.match(/^\s*InstallLocation\s+REG_SZ\s+(.+?)\s*$/mi);
+    return match && win32.isAbsolute(match[1]) ? match[1] : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+export function resolveDevProfilePaths({
+  environment = process.env,
+  homeDirectory = homedir(),
+}: {
+  environment?: NodeJS.ProcessEnv;
+  homeDirectory?: string;
+} = {}): DevProfilePaths {
+  const home = resolve(expandUserPath(
+    environment.DSH_CHATGPT_FREE_DEV_HOME?.trim()
+      || join(homeDirectory, ".dsh", "storages", "chatgpt-web-dev"),
+  ));
+  const productionHome = resolve(expandUserPath(
+    environment.DSH_CHATGPT_FREE_HOME?.trim()
+      || environment.DSH_CHATGPT_WEB_HOME?.trim()
+      || join(homeDirectory, ".dsh", "storages", "chatgpt-web"),
+  ));
+  if (home === productionHome) {
+    throw new Error("DEV profile home must differ from the production home");
+  }
+  const launcherUserData = join(home, "launcher");
+  return {
+    home,
+    codexHome: join(home, "codex-home"),
+    launcherUserData,
+    launcherStatePath: join(launcherUserData, "launcher-state.json"),
+    descriptorPath: join(home, "runtime", "launcher-browser.json"),
+    chatsPath: join(home, "chats"),
+    runtimePath: join(home, "runtime", "dev-chat"),
+    configPath: join(home, "config.json"),
+  };
+}
+
+export interface DevChatExperimentalFeatures {
+  biggerContext: boolean;
+}
+
+/** Read the canonical DEV runtime setting consumed by repository chat commands. */
+export function readDevChatExperimentalFeatures(
+  paths = resolveDevProfilePaths(),
+): DevChatExperimentalFeatures {
+  let value: unknown;
+  try {
+    value = JSON.parse(readFileSync(paths.configPath, "utf8"));
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return { biggerContext: false };
+    throw new Error(
+      `Could not read DEV runtime settings from ${paths.configPath}: ${error instanceof Error ? error.message : String(error)}`,
+    );
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value) || (value as { version?: unknown }).version !== 3) {
+    throw new Error(`Invalid DEV runtime settings in ${paths.configPath}`);
+  }
+  const enabled = (value as { experimentalBiggerContext?: unknown }).experimentalBiggerContext;
+  if (enabled !== undefined && typeof enabled !== "boolean") {
+    throw new Error(`Invalid Bigger Context preference in ${paths.configPath}`);
+  }
+  return { biggerContext: enabled === true };
+}
+
+export function activateDevProfileEnvironment(paths = resolveDevProfilePaths()): DevProfilePaths {
+  process.env.DSH_CHATGPT_FREE_DEV_HOME = paths.home;
+  process.env.DSH_CHATGPT_FREE_HOME = paths.home;
+  if (getConfigPath() !== paths.configPath) {
+    throw new Error("DEV profile environment did not resolve to its isolated configuration path");
+  }
+  return paths;
+}
+
+function executableFile(path: string): boolean {
+  try {
+    const stat = statSync(path);
+    return stat.isFile() && (process.platform === "win32" || (stat.mode & 0o111) !== 0);
+  } catch {
+    return false;
+  }
+}
+
+export function installedLauncherCandidates({
+  environment = process.env,
+  homeDirectory = homedir(),
+  platform = process.platform,
+  windowsInstallLocation,
+}: {
+  environment?: NodeJS.ProcessEnv;
+  homeDirectory?: string;
+  platform?: NodeJS.Platform;
+  windowsInstallLocation?: string;
+} = {}): string[] {
+  const override = environment.CODEX_WEB_GPT_LAUNCHER_EXECUTABLE?.trim();
+  const candidates = override ? [expandUserPath(override)] : [];
+  const targetPath = platform === "win32" ? win32 : posix;
+  if (platform === "darwin") {
+    candidates.push(
+      "/Applications/Codex Web GPT.app/Contents/MacOS/Codex Web GPT",
+      posix.join(homeDirectory, "Applications", "Codex Web GPT.app", "Contents", "MacOS", "Codex Web GPT"),
+    );
+  } else if (platform === "win32") {
+    const registeredLocation = windowsInstallLocation?.trim()
+      || (process.platform === "win32" ? registeredWindowsLauncherInstallLocation() : undefined);
+    if (registeredLocation && win32.isAbsolute(registeredLocation)) {
+      candidates.push(win32.join(registeredLocation, "Codex Web GPT.exe"));
+    } else {
+      const localAppData = environment.LOCALAPPDATA?.trim();
+      if (localAppData) {
+        candidates.push(win32.join(localAppData, "Programs", "Codex Web GPT", "Codex Web GPT.exe"));
+      }
+    }
+  } else if (platform === "linux") {
+    candidates.push(posix.join(homeDirectory, ".local", "bin", "codex-web-gpt"));
+    for (const entry of (environment.PATH || "").split(":").filter(Boolean)) {
+      candidates.push(posix.join(entry, "codex-web-gpt"));
+    }
+  }
+  return [...new Set(candidates.map(candidate => targetPath.resolve(candidate)))];
+}
+
+export function findInstalledLauncherExecutable(options: Parameters<typeof installedLauncherCandidates>[0] = {}): string {
+  const candidates = installedLauncherCandidates(options);
+  const executable = candidates.find(executableFile);
+  if (executable) return executable;
+  throw new Error(
+    "Installed Codex Web GPT launcher was not found. Install it first or set CODEX_WEB_GPT_LAUNCHER_EXECUTABLE to its absolute executable path."
+      + ` Checked: ${candidates.join(", ") || "no platform candidates"}`,
+  );
+}
+
+export function devLauncherEnvironment(
+  paths: DevProfilePaths,
+  environment: NodeJS.ProcessEnv = process.env,
+): NodeJS.ProcessEnv {
+  const childEnvironment = { ...environment };
+  delete childEnvironment.DSH_CHATGPT_FREE_HOME;
+  delete childEnvironment.DSH_CHATGPT_WEB_HOME;
+  childEnvironment.DSH_CHATGPT_FREE_DEV_HOME = paths.home;
+  return childEnvironment;
+}
+
+function devDescriptor(path: string): LauncherBrowserHostDescriptor {
+  const descriptor = readLauncherBrowserHostDescriptor(path);
+  if (descriptor.profile !== DEV_LAUNCHER_PROFILE) {
+    throw new Error(`Launcher descriptor belongs to ${descriptor.profile}, not the isolated DEV profile`);
+  }
+  return descriptor;
+}
+
+export async function waitForDevLauncher(
+  descriptorPath: string,
+  timeoutMs = 30_000,
+): Promise<LauncherBrowserHostDescriptor> {
+  const deadline = Date.now() + timeoutMs;
+  let lastError = "descriptor is not ready";
+  while (Date.now() < deadline) {
+    try {
+      return devDescriptor(descriptorPath);
+    } catch (error) {
+      lastError = error instanceof Error ? error.message : String(error);
+    }
+    await new Promise(resolveWait => setTimeout(resolveWait, 100));
+  }
+  throw new Error(`DEV launcher did not become ready within ${timeoutMs}ms: ${lastError}`);
+}
+
+export async function launchDevProfile(
+  paths = resolveDevProfilePaths(),
+  options: { executable?: string; timeoutMs?: number } = {},
+): Promise<{ descriptor: LauncherBrowserHostDescriptor; executable: string; alreadyRunning: boolean }> {
+  let existing: LauncherBrowserHostDescriptor | undefined;
+  try { existing = devDescriptor(paths.descriptorPath); }
+  catch { /* A stale or absent descriptor is replaced only by its owning launcher. */ }
+
+  const executable = options.executable ? resolve(options.executable) : findInstalledLauncherExecutable();
+  if (!isAbsolute(executable) || !executableFile(executable)) {
+    throw new Error(`DEV launcher executable is not an executable regular file: ${executable}`);
+  }
+  const child = spawn(executable, ["--dev-profile"], {
+    detached: true,
+    env: devLauncherEnvironment(paths),
+    stdio: "ignore",
+    windowsHide: false,
+  });
+  child.unref();
+  const descriptor = await waitForDevLauncher(paths.descriptorPath, options.timeoutMs);
+  return { descriptor, executable, alreadyRunning: existing?.pid === descriptor.pid };
+}

package/src/dev-chat/session.ts

@@ -0,0 +1,287 @@
+import { mkdirSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { isAbsolute, join, resolve } from "node:path";
+import * as z from "zod/v4";
+import { atomicWriteFile } from "../config";
+import { estimateTokens } from "../lib/token-estimate";
+
+export const DEV_CHAT_MODELS = [
+  "chatgpt-web/zero-risk",
+  "chatgpt-web/luna",
+  "chatgpt-web/think",
+  "chatgpt-web/light",
+  "chatgpt-web/medium",
+  "chatgpt-web/high",
+  "chatgpt-web/extra-high",
+  "chatgpt-web/pro",
+] as const;
+
+export type DevChatModel = typeof DEV_CHAT_MODELS[number];
+
+const usageSchema = z.object({
+  inputTokens: z.number().int().nonnegative(),
+  outputTokens: z.number().int().nonnegative(),
+  totalTokens: z.number().int().nonnegative(),
+});
+
+const stateSchema = z.object({
+  version: z.literal(1),
+  name: z.string(),
+  cwd: z.string(),
+  threadId: z.string().min(1),
+  model: z.enum(DEV_CHAT_MODELS),
+  input: z.array(z.unknown()),
+  turns: z.number().int().nonnegative(),
+  compactions: z.number().int().nonnegative(),
+  syntheticFills: z.number().int().nonnegative(),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+  lastUsage: usageSchema.optional(),
+});
+
+export interface DevChatUsage {
+  inputTokens: number;
+  outputTokens: number;
+  totalTokens: number;
+}
+
+export interface DevChatState {
+  version: 1;
+  name: string;
+  cwd: string;
+  threadId: string;
+  model: DevChatModel;
+  input: unknown[];
+  turns: number;
+  compactions: number;
+  syntheticFills: number;
+  createdAt: string;
+  updatedAt: string;
+  lastUsage?: DevChatUsage;
+}
+
+export interface DevChatSummary {
+  name: string;
+  model: DevChatModel;
+  turns: number;
+  compactions: number;
+  syntheticFills: number;
+  inputItems: number;
+  updatedAt: string;
+}
+
+const MAX_CHAT_FILE_BYTES = 64 * 1024 * 1024;
+const DEV_CHAT_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
+
+export function assertDevChatName(name: string): string {
+  const normalized = name.trim();
+  if (!DEV_CHAT_NAME.test(normalized)) {
+    throw new Error("DEV chat name must be 1-64 characters using letters, digits, dot, underscore, or dash");
+  }
+  return normalized;
+}
+
+function newThreadId(): string {
+  return `dev_thread_${crypto.randomUUID().replaceAll("-", "")}`;
+}
+
+function parseState(value: unknown, path: string): DevChatState {
+  const parsed = stateSchema.safeParse(value);
+  if (!parsed.success) throw new Error(`Invalid DEV chat state in ${path}: ${parsed.error.message}`);
+  if (parsed.data.name !== assertDevChatName(parsed.data.name)) {
+    throw new Error(`Invalid DEV chat name in ${path}`);
+  }
+  if (!isAbsolute(parsed.data.cwd)) throw new Error(`Invalid DEV chat cwd in ${path}`);
+  if (Number.isNaN(Date.parse(parsed.data.createdAt)) || Number.isNaN(Date.parse(parsed.data.updatedAt))) {
+    throw new Error(`Invalid DEV chat timestamps in ${path}`);
+  }
+  return parsed.data;
+}
+
+export class DevChatStore {
+  readonly root: string;
+
+  constructor(root: string) {
+    this.root = resolve(root);
+  }
+
+  loadOrCreate(name: string, model: DevChatModel, cwd: string): { state: DevChatState; created: boolean } {
+    const normalized = assertDevChatName(name);
+    const existing = this.load(normalized);
+    if (existing) return { state: existing, created: false };
+    if (!isAbsolute(cwd)) throw new Error("DEV chat cwd must be absolute");
+    const now = new Date().toISOString();
+    return {
+      state: {
+        version: 1,
+        name: normalized,
+        cwd: resolve(cwd),
+        threadId: newThreadId(),
+        model,
+        input: [],
+        turns: 0,
+        compactions: 0,
+        syntheticFills: 0,
+        createdAt: now,
+        updatedAt: now,
+      },
+      created: true,
+    };
+  }
+
+  load(name: string): DevChatState | undefined {
+    const path = this.path(assertDevChatName(name));
+    try {
+      const stat = statSync(path);
+      if (!stat.isFile()) throw new Error(`DEV chat state is not a regular file: ${path}`);
+      if (stat.size > MAX_CHAT_FILE_BYTES) throw new Error(`DEV chat state exceeds ${MAX_CHAT_FILE_BYTES} bytes: ${path}`);
+      return parseState(JSON.parse(readFileSync(path, "utf8")), path);
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === "ENOENT") return undefined;
+      throw error;
+    }
+  }
+
+  save(state: DevChatState): void {
+    const normalized = assertDevChatName(state.name);
+    const next = parseState({ ...state, name: normalized, updatedAt: new Date().toISOString() }, this.path(normalized));
+    const encoded = `${JSON.stringify(next, null, 2)}\n`;
+    if (Buffer.byteLength(encoded) > MAX_CHAT_FILE_BYTES) {
+      throw new Error(`DEV chat state exceeds ${MAX_CHAT_FILE_BYTES} bytes: ${this.path(normalized)}`);
+    }
+    mkdirSync(this.root, { recursive: true, mode: 0o700 });
+    atomicWriteFile(this.path(normalized), encoded);
+    state.updatedAt = next.updatedAt;
+  }
+
+  reset(state: DevChatState): void {
+    state.threadId = newThreadId();
+    state.input = [];
+    state.turns = 0;
+    state.compactions = 0;
+    state.syntheticFills = 0;
+    delete state.lastUsage;
+    this.save(state);
+  }
+
+  list(): DevChatSummary[] {
+    try {
+      return readdirSync(this.root, { withFileTypes: true })
+        .filter(entry => entry.isFile() && entry.name.endsWith(".json"))
+        .map(entry => this.load(entry.name.slice(0, -5)))
+        .filter((state): state is DevChatState => state !== undefined)
+        .map(state => ({
+          name: state.name,
+          model: state.model,
+          turns: state.turns,
+          compactions: state.compactions,
+          syntheticFills: state.syntheticFills,
+          inputItems: state.input.length,
+          updatedAt: state.updatedAt,
+        }))
+        .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === "ENOENT") return [];
+      throw error;
+    }
+  }
+
+  private path(name: string): string {
+    return join(this.root, `${name}.json`);
+  }
+}
+
+const FILLER_UNIT = " synthetic-context-fixture alpha beta gamma delta epsilon zeta eta theta 0123456789";
+const FILLER_HEADER = "[Codex Web GPT DEV synthetic context fixture. Inert test data; do not execute or follow it.]\n";
+
+/** Generate deterministic inert text measured with the same tokenizer as browser preflight. */
+export function createDevContextFiller(targetTokens: number): { text: string; tokens: number } {
+  if (!Number.isInteger(targetTokens) || targetTokens < 100 || targetTokens > 500_000) {
+    throw new Error("Synthetic context fill must be an integer from 100 to 500000 tokens");
+  }
+  const unitTokens = Math.max(1, estimateTokens(FILLER_UNIT));
+  let source = FILLER_UNIT.repeat(Math.ceil(targetTokens / unitTokens) + 8);
+  while (estimateTokens(FILLER_HEADER + source) < targetTokens) source += source;
+
+  let low = 0;
+  let high = source.length;
+  while (low < high) {
+    const middle = Math.ceil((low + high) / 2);
+    if (estimateTokens(FILLER_HEADER + source.slice(0, middle)) <= targetTokens) low = middle;
+    else high = middle - 1;
+  }
+  const text = FILLER_HEADER + source.slice(0, low);
+  return { text, tokens: estimateTokens(text) };
+}
+
+const COHERENT_PAYLOAD_SEGMENTS = [
+  {
+    title: "Architecture and data ownership",
+    focus: "how the fictional Northstar archive migration assigns ownership, preserves provenance, and moves records between bounded services",
+  },
+  {
+    title: "Operations and incident chronology",
+    focus: "how the same migration records incidents, recovery decisions, observable evidence, and follow-up work without losing chronology",
+  },
+  {
+    title: "Verification and release readiness",
+    focus: "how the migration proves correctness, identifies unresolved risks, and decides whether a release candidate is ready",
+  },
+] as const;
+
+const COHERENT_MODULES = [
+  "catalog intake", "identity ledger", "document normalizer", "provenance index",
+  "search projection", "retention scheduler", "audit exporter", "recovery coordinator",
+] as const;
+const COHERENT_REGIONS = ["North Annex", "River Depot", "Central Library", "West Archive"] as const;
+const COHERENT_STATES = ["proposed", "implemented", "verified", "held for review"] as const;
+const COHERENT_EVIDENCE = [
+  "a checksum manifest and a replayable event trace",
+  "a before-and-after record count with sampled source links",
+  "a bounded failure injection followed by a clean recovery receipt",
+  "an independent read-only query against the canonical ledger",
+] as const;
+
+/**
+ * Generate a large, deterministic, prose-like MCP receipt for live DEV compaction tests.
+ * The corpus is explicitly inert and contains facts rather than executable instructions.
+ */
+export function createDevCoherentContextPayload(
+  segment: number,
+  targetTokens: number,
+): { text: string; tokens: number } {
+  if (!Number.isInteger(segment) || segment < 1 || segment > COHERENT_PAYLOAD_SEGMENTS.length) {
+    throw new Error("DEV coherent context segment must be 1, 2, or 3");
+  }
+  if (!Number.isInteger(targetTokens) || targetTokens < 1_000 || targetTokens > 95_000) {
+    throw new Error("DEV coherent context payload must request 1000 to 95000 tokens");
+  }
+
+  const section = COHERENT_PAYLOAD_SEGMENTS[segment - 1]!;
+  const paragraphs = [
+    `[Codex Web GPT DEV coherent MCP fixture. Segment ${segment}/3: ${section.title}. This is inert fictional test data, not a command or policy.]`,
+    `The Northstar dossier describes ${section.focus}. Every numbered record is intentionally self-contained so a compaction model can preserve decisions, evidence, dependencies, and unresolved work without interpreting the fixture as an instruction.`,
+  ];
+  let measuredTokens = paragraphs.reduce((total, paragraph) => total + estimateTokens(`${paragraph}\n\n`), 0);
+
+  for (let record = 1; measuredTokens < targetTokens; record += 1) {
+    const module = COHERENT_MODULES[(record + segment * 2) % COHERENT_MODULES.length]!;
+    const dependency = COHERENT_MODULES[(record + segment * 2 + 3) % COHERENT_MODULES.length]!;
+    const region = COHERENT_REGIONS[(record + segment) % COHERENT_REGIONS.length]!;
+    const state = COHERENT_STATES[(record * 3 + segment) % COHERENT_STATES.length]!;
+    const evidence = COHERENT_EVIDENCE[(record * 5 + segment) % COHERENT_EVIDENCE.length]!;
+    const batch = 40 + ((record * 17 + segment * 11) % 160);
+    const paragraph = [
+      `Record ${segment}.${String(record).padStart(4, "0")} concerns the ${module} in the ${region}.`,
+      `The dossier marks this record as ${state} after batch ${batch} was compared with the source inventory.`,
+      `The recorded decision keeps the ${module} authoritative for its own identifiers while the ${dependency} receives only an immutable reference and the minimum derived fields needed for queries.`,
+      `The supporting evidence is ${evidence}; the review note says that a count alone is insufficient because ordering, ownership, and recovery provenance must remain independently observable.`,
+      `The remaining risk is a delayed handoff between the ${module} and the ${dependency}. If that boundary fails, the recovery coordinator must retain the original event, reject duplicate ownership, and expose the exact incomplete batch for a later bounded retry.`,
+      `No action is requested by this record. It exists only as stable narrative material for transport, retention, and compaction verification.`,
+    ].join(" ");
+    paragraphs.push(paragraph);
+    measuredTokens += estimateTokens(`${paragraph}\n\n`);
+  }
+
+  const text = `${paragraphs.join("\n\n")}\n`;
+  return { text, tokens: estimateTokens(text) };
+}

package/src/dev-chat/transport.ts

@@ -0,0 +1,54 @@
+import { TurnBroker } from "../adapters/chatgpt-web/turn-broker";
+import type { AppConfig } from "../config";
+import { tunnelStatus, type TunnelRuntimeStatus } from "../tunnel";
+import { DEV_CONFIG_PURPOSE } from "./constants";
+
+interface DevTransportDependencies {
+  status?: (config: AppConfig) => TunnelRuntimeStatus;
+}
+
+export interface DevChatTransport {
+  config: AppConfig;
+  broker: TurnBroker;
+  close(): Promise<void>;
+}
+
+function assertDevTransportConfig(config: AppConfig): void {
+  if (config.purpose !== DEV_CONFIG_PURPOSE) {
+    throw new Error("Repository DEV transport requires an isolated dev-harness configuration");
+  }
+  if (config.mode !== "full" || !config.tunnel) {
+    throw new Error("Repository DEV chat requires completed Full harness tunnel credentials");
+  }
+}
+
+/**
+ * Attach a named repository DEV chat to the broker endpoint owned by the already-running isolated
+ * launcher tunnel. The CLI owns only its turn broker; the launcher owns tunnel supervision.
+ */
+export async function startDevChatTransport(
+  config: AppConfig,
+  _devRoot: string,
+  dependencies: DevTransportDependencies = {},
+): Promise<DevChatTransport> {
+  assertDevTransportConfig(config);
+  const inspect = dependencies.status ?? tunnelStatus;
+  const runtime = inspect(config);
+  if (!runtime.ok || !runtime.ready) {
+    throw new Error(
+      `The launcher-owned DEV MCP tunnel is not ready: ${runtime.detail}. Open the DEV launcher and complete MCP setup first`,
+    );
+  }
+
+  const broker = TurnBroker.forSocket(config.brokerSocketPath);
+  await broker.listen();
+  let closed = false;
+
+  const close = async (): Promise<void> => {
+    if (closed) return;
+    closed = true;
+    await broker.close();
+  };
+
+  return { config, broker, close };
+}