@wlv-zedd/dsh-chatgpt-web 1.0.0

package/lib/plugin.js

@@ -0,0 +1,195 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/plugin.ts
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { pathToFileURL } from "node:url";
+var name = "dsh-chatgpt-web";
+var inject = [];
+var ROOT_DIR = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+function resolveLauncher(customBunPath) {
+  const libCliPath = resolve(ROOT_DIR, "lib", "cli.js");
+  if (existsSync(libCliPath)) {
+    return {
+      cmd: process.execPath,
+      args: [libCliPath, "serve"]
+    };
+  }
+  if (customBunPath && existsSync(customBunPath)) {
+    return { cmd: customBunPath, args: ["run", "src/cli.ts", "serve"] };
+  }
+  const winBun = join(homedir(), ".bun", "bin", "bun.exe");
+  if (existsSync(winBun)) {
+    return { cmd: winBun, args: ["run", "src/cli.ts", "serve"] };
+  }
+  const tsxPath = resolve(ROOT_DIR, "../deepseek-harness/node_modules/tsx/dist/esm/index.mjs");
+  if (existsSync(tsxPath)) {
+    return {
+      cmd: process.execPath,
+      args: ["--import", pathToFileURL(tsxPath).href, "src/cli.ts", "serve"]
+    };
+  }
+  return { cmd: process.execPath, args: ["src/cli.ts", "serve"] };
+}
+async function isSidecarHealthy(host, port) {
+  try {
+    const controller = new AbortController;
+    const timer = setTimeout(() => controller.abort(), 1500);
+    const res = await fetch(`http://${host}:${port}/healthz`, {
+      signal: controller.signal
+    });
+    clearTimeout(timer);
+    if (!res.ok)
+      return false;
+    const body = await res.json();
+    return body.status === "ok";
+  } catch {
+    return false;
+  }
+}
+function apply(ctx, config = {}) {
+  const host = config.host || "127.0.0.1";
+  const port = config.port || 17841;
+  const autoStart = config.autoStart !== false;
+  const readyTimeoutMs = config.readyTimeoutMs || 30000;
+  const logger = typeof ctx.logger === "function" ? ctx.logger("chatgpt-web") : console;
+  let spawnedProcess;
+  const startDaemon = async () => {
+    const alreadyHealthy = await isSidecarHealthy(host, port);
+    if (alreadyHealthy) {
+      logger.info(`[dsh-chatgpt-web] Sidecar already running and healthy at http://${host}:${port}/v1`);
+      return;
+    }
+    if (!autoStart) {
+      logger.warn(`[dsh-chatgpt-web] Sidecar is offline and autoStart is false. Start it manually with 'bun run src/cli.ts serve'`);
+      return;
+    }
+    const launcher = resolveLauncher(config.bunPath);
+    logger.info(`[dsh-chatgpt-web] Starting dsh-chatgpt-web daemon via ${launcher.cmd} at http://${host}:${port}/v1...`);
+    const child = spawn(launcher.cmd, launcher.args, {
+      cwd: ROOT_DIR,
+      stdio: ["ignore", "pipe", "pipe"],
+      windowsHide: true,
+      env: {
+        ...process.env
+      }
+    });
+    spawnedProcess = child;
+    child.stdout?.on("data", (chunk) => {
+      const text = chunk.toString().trim();
+      if (text && typeof logger.debug === "function")
+        logger.debug(`[sidecar] ${text}`);
+    });
+    child.stderr?.on("data", (chunk) => {
+      const text = chunk.toString().trim();
+      if (text && typeof logger.debug === "function")
+        logger.debug(`[sidecar:err] ${text}`);
+    });
+    child.on("error", (err) => {
+      logger.error(`[dsh-chatgpt-web] Failed to launch sidecar process: ${err.message}`);
+    });
+    child.on("exit", (code, signal) => {
+      if (code !== 0 && code !== null) {
+        logger.warn(`[dsh-chatgpt-web] Sidecar process exited with code ${code} (signal: ${signal})`);
+      }
+      spawnedProcess = undefined;
+    });
+    const deadline = Date.now() + readyTimeoutMs;
+    while (Date.now() < deadline) {
+      if (await isSidecarHealthy(host, port)) {
+        logger.info(`[dsh-chatgpt-web] Sidecar ready and accepting turns at http://${host}:${port}/v1`);
+        return;
+      }
+      await new Promise((r) => setTimeout(r, 500));
+    }
+    logger.error(`[dsh-chatgpt-web] Sidecar did not become healthy within ${readyTimeoutMs}ms`);
+  };
+  const stopDaemon = async () => {
+    if (!spawnedProcess)
+      return;
+    logger.info("[dsh-chatgpt-web] Stopping sidecar daemon...");
+    try {
+      const controller = new AbortController;
+      const timer = setTimeout(() => controller.abort(), 2000);
+      await fetch(`http://${host}:${port}/admin/shutdown`, {
+        method: "POST",
+        signal: controller.signal
+      }).catch(() => {});
+      clearTimeout(timer);
+    } catch {}
+    if (spawnedProcess && !spawnedProcess.killed) {
+      spawnedProcess.kill("SIGTERM");
+    }
+    spawnedProcess = undefined;
+  };
+  if (typeof ctx.effect === "function") {
+    ctx.effect(() => {
+      startDaemon();
+      return () => {
+        stopDaemon();
+      };
+    });
+  } else {
+    startDaemon();
+    process.once("beforeExit", () => void stopDaemon());
+  }
+}
+var plugin_default = {
+  name,
+  inject,
+  apply
+};
+export {
+  name,
+  inject,
+  plugin_default as default,
+  apply
+};

package/package.json

@@ -0,0 +1,88 @@
+{
+  "name": "@wlv-zedd/dsh-chatgpt-web",
+  "version": "1.0.0",
+  "description": "DeepSeek Harness Cordis plugin for free ChatGPT Web (GPT 5.6 Luna) pure chat and zero API fees.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/WLV-ZEDD/dsh-chatgpt-web.git"
+  },
+  "homepage": "https://github.com/WLV-ZEDD/dsh-chatgpt-web#readme",
+  "bugs": {
+    "url": "https://github.com/WLV-ZEDD/dsh-chatgpt-web/issues"
+  },
+  "author": "WLV-ZEDD",
+  "type": "module",
+  "main": "./lib/plugin.js",
+  "bin": {
+    "dsh-chatgpt-web": "./lib/cli.js"
+  },
+  "exports": {
+    ".": "./lib/plugin.js",
+    "./cordis.patch.yml": "./cordis.patch.yml",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib",
+    "src",
+    "assets",
+    "cordis.patch.yml",
+    "screenshots.json",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  },
+  "scripts": {
+    "build": "bun build src/cli.ts src/plugin.ts --outdir lib --target node --format esm",
+    "start": "node lib/cli.js serve",
+    "setup": "node lib/cli.js setup",
+    "login": "node lib/cli.js login",
+    "doctor": "node lib/cli.js doctor",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.30.0",
+    "ajv": "8.20.0",
+    "ajv-formats": "3.0.1",
+    "chromium-bidi": "12.1.0",
+    "fflate": "^0.8.2",
+    "playwright-core": "^1.62.0",
+    "tiktoken": "1.0.22",
+    "turndown": "7.2.0",
+    "turndown-plugin-gfm": "1.0.2",
+    "zod": "4.4.3"
+  },
+  "devDependencies": {
+    "@types/bun": "1.4.0",
+    "@types/turndown": "5.0.5",
+    "typescript": "5.9.3"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^3.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@deepseek-ai/cordis": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "bun": ">=1.3.0",
+    "node": ">=22.19.0"
+  },
+  "keywords": [
+    "deepseek-harness",
+    "dsh-plugin",
+    "chatgpt",
+    "chatgpt-web",
+    "playwright",
+    "responses-api",
+    "free-ai"
+  ],
+  "license": "MIT"
+}

package/screenshots.json

@@ -0,0 +1,5 @@
+[
+  "assets/promo-dshmarket-official.png",
+  "assets/hero-demo.png",
+  "assets/demo.gif"
+]

package/src/adapters/base.ts

@@ -0,0 +1,16 @@
+import type { AdapterEvent, CodexParsedRequest } from "../types";
+
+/** Metadata about the caller's incoming request, for auth-forwarding adapters. */
+export interface IncomingMeta {
+  headers: Headers;
+  abortSignal?: AbortSignal;
+}
+
+export interface ProviderAdapter {
+  name: string;
+  runTurn(
+    parsed: CodexParsedRequest,
+    incoming: IncomingMeta,
+    emit: (event: AdapterEvent) => void,
+  ): Promise<void>;
+}

package/src/adapters/chatgpt-web/adapter-error.ts

@@ -0,0 +1,59 @@
+export interface ChatGptWebAdapterErrorOptions {
+  status: number;
+  errorType: string;
+  code: string;
+  retryable: boolean;
+  cause?: unknown;
+}
+
+export class ChatGptWebAdapterError extends Error {
+  readonly status: number;
+  readonly errorType: string;
+  readonly code: string;
+  readonly retryable: boolean;
+
+  constructor(message: string, options: ChatGptWebAdapterErrorOptions) {
+    super(message, options.cause === undefined ? undefined : { cause: options.cause });
+    this.name = "ChatGptWebAdapterError";
+    this.status = options.status;
+    this.errorType = options.errorType;
+    this.code = options.code;
+    this.retryable = options.retryable;
+  }
+}
+
+export function chatGptBrowserTabClosedError(): ChatGptWebAdapterError {
+  return new ChatGptWebAdapterError(
+    "The ChatGPT browser tab was closed, so the Codex turn was cancelled.",
+    {
+      status: 499,
+      errorType: "client_closed_request",
+      code: "client_cancelled",
+      retryable: false,
+    },
+  );
+}
+
+export function chatGptStoppedThinkingError(): ChatGptWebAdapterError {
+  return new ChatGptWebAdapterError(
+    "ChatGPT remained in 'Stopped thinking' for 5 seconds, so the Codex turn was cancelled.",
+    {
+      status: 499,
+      errorType: "client_closed_request",
+      code: "client_cancelled",
+      retryable: false,
+    },
+  );
+}
+
+export function chatGptRetainedConversationUnavailableError(): ChatGptWebAdapterError {
+  return new ChatGptWebAdapterError(
+    "The retained ChatGPT conversation is no longer available.",
+    {
+      status: 409,
+      errorType: "invalid_request_error",
+      code: "compaction_source_unavailable",
+      retryable: false,
+    },
+  );
+}