heyhank 0.1.0

package/server/codex-container-auth.ts

@@ -0,0 +1,24 @@
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+/**
+ * Returns true when Codex running inside a container has a plausible auth source:
+ * - explicit OpenAI auth env vars, or
+ * - known auth files under ~/.codex that can be copied into the container.
+ */
+export function hasContainerCodexAuth(envVars?: Record<string, string>): boolean {
+  if (
+    !!envVars?.OPENAI_API_KEY
+    || !!envVars?.CODEX_API_KEY
+  ) {
+    return true;
+  }
+
+  const home = process.env.HOME || process.env.USERPROFILE || homedir();
+  const candidates = [
+    join(home, ".codex", "auth.json"),
+  ];
+
+  return candidates.some((p) => existsSync(p));
+}

package/server/codex-home.ts

@@ -0,0 +1,27 @@
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import { HEYHANK_HOME } from "./paths.js";
+
+export const DEFAULT_HEYHANK_CODEX_HOME = join(
+  HEYHANK_HOME,
+  "codex-home",
+);
+
+export function getLegacyCodexHome(): string {
+  return join(homedir(), ".codex");
+}
+
+export function resolveHeyHankCodexHome(explicitCodexHome?: string): string {
+  // Intentionally do NOT fall back to process.env.CODEX_HOME here.
+  // That env var points to the user's global Codex home (~/.codex), which
+  // would break per-session isolation by nesting session dirs inside it.
+  return resolve(explicitCodexHome || DEFAULT_HEYHANK_CODEX_HOME);
+}
+
+export function resolveHeyHankCodexSessionHome(
+  sessionId: string,
+  explicitCodexHome?: string,
+): string {
+  return join(resolveHeyHankCodexHome(explicitCodexHome), sessionId);
+}
+

package/server/codex-ws-proxy.cjs

@@ -0,0 +1,226 @@
+#!/usr/bin/env node
+"use strict";
+
+// Bridges newline-delimited JSON on stdin/stdout to WebSocket text frames for
+// Codex app-server. Runs in real Node (not Bun) so the `ws` package handles the
+// Codex Rust server handshake correctly with perMessageDeflate disabled.
+
+const readline = require("node:readline");
+const WebSocket = require("ws");
+
+const url = process.argv[2];
+const timeoutMs = Number(process.argv[3] || "30000");
+const pongTimeoutArg = process.argv[4];
+
+if (!url) {
+  process.stderr.write("[codex-ws-proxy] Missing URL argument\n");
+  process.exit(2);
+}
+
+let ws = null;
+let opened = false;
+let closed = false;
+let exiting = false;
+let queue = [];
+let connectAttempt = 0;
+const startedAt = Date.now();
+
+// Reconnection state — after a successful initial connection, transient
+// WebSocket drops are retried with exponential backoff before giving up.
+const MAX_RECONNECT_ATTEMPTS = 10;
+const RECONNECT_BASE_MS = 200;
+const RECONNECT_MAX_MS = 5000;
+let reconnecting = false;
+let reconnectAttempt = 0;
+
+// Heartbeat — detect zombie WebSocket connections where the TCP socket is open
+// but the remote Codex process has stopped responding.
+const PING_INTERVAL_MS = 30000;
+const PONG_TIMEOUT_MS = pongTimeoutArg ? Number(pongTimeoutArg) : 30000;
+let pingTimer = null;
+let pongTimer = null;
+
+function log(msg) {
+  process.stderr.write(`[codex-ws-proxy] ${msg}\n`);
+}
+
+function startHeartbeat() {
+  stopHeartbeat();
+  pingTimer = setInterval(() => {
+    if (!ws || ws.readyState !== WebSocket.OPEN) return;
+    if (pongTimer) { clearTimeout(pongTimer); pongTimer = null; }
+    ws.ping();
+    pongTimer = setTimeout(() => {
+      log("Pong timeout — connection appears dead");
+      try { ws.terminate(); } catch {}
+      // terminate() fires the close event which triggers scheduleReconnect
+    }, PONG_TIMEOUT_MS);
+  }, PING_INTERVAL_MS);
+}
+
+function stopHeartbeat() {
+  if (pingTimer) { clearInterval(pingTimer); pingTimer = null; }
+  if (pongTimer) { clearTimeout(pongTimer); pongTimer = null; }
+}
+
+function decodeMessageData(data) {
+  if (typeof data === "string") return data;
+  if (Buffer.isBuffer(data)) return data.toString("utf8");
+  if (Array.isArray(data)) return Buffer.concat(data.map((x) => Buffer.from(x))).toString("utf8");
+  if (data instanceof ArrayBuffer) return Buffer.from(data).toString("utf8");
+  if (ArrayBuffer.isView(data)) return Buffer.from(data.buffer, data.byteOffset, data.byteLength).toString("utf8");
+  return String(data);
+}
+
+function flushQueue() {
+  if (!ws || ws.readyState !== WebSocket.OPEN || queue.length === 0) return;
+  for (const line of queue) {
+    ws.send(line);
+  }
+  queue = [];
+}
+
+function failAndExit(message, code = 1) {
+  if (exiting) return;
+  exiting = true;
+  stopHeartbeat();
+  log(message);
+  try { if (ws) ws.close(); } catch {}
+  process.exit(code);
+}
+
+/**
+ * Attempt to reconnect after a post-open WebSocket drop.
+ * Uses exponential backoff up to MAX_RECONNECT_ATTEMPTS before giving up.
+ */
+function scheduleReconnect(reason) {
+  if (closed || exiting) return;
+  stopHeartbeat();
+  reconnectAttempt++;
+  if (reconnectAttempt > MAX_RECONNECT_ATTEMPTS) {
+    failAndExit(`WebSocket reconnection failed after ${MAX_RECONNECT_ATTEMPTS} attempts (last: ${reason})`);
+    return;
+  }
+
+  reconnecting = true;
+  const delay = Math.min(RECONNECT_BASE_MS * Math.pow(2, reconnectAttempt - 1), RECONNECT_MAX_MS);
+  log(`Reconnecting in ${delay}ms (attempt ${reconnectAttempt}/${MAX_RECONNECT_ATTEMPTS}) — ${reason}`);
+  setTimeout(connect, delay);
+}
+
+function connect() {
+  if (closed || exiting) return;
+
+  // During initial connection (before first successful open), enforce timeout.
+  if (!opened) {
+    connectAttempt += 1;
+    const elapsed = Date.now() - startedAt;
+    if (elapsed > timeoutMs) {
+      failAndExit(`Failed to connect within ${timeoutMs}ms`);
+      return;
+    }
+  }
+
+  ws = new WebSocket(url, { perMessageDeflate: false });
+
+  ws.once("open", () => {
+    if (!opened) {
+      opened = true;
+    }
+    const wasReconnect = reconnecting;
+    if (reconnecting) {
+      log(`Reconnected successfully (attempt ${reconnectAttempt})`);
+      reconnecting = false;
+      reconnectAttempt = 0;
+    }
+    startHeartbeat();
+    flushQueue();
+    // Notify the adapter AFTER flushing any buffered messages so stale Codex
+    // responses from the pre-drop session are delivered before the adapter
+    // rejects all pending calls and cleans up.
+    if (wasReconnect) {
+      const reconnectNotification = JSON.stringify({
+        method: "companion/wsReconnected",
+        params: {},
+      });
+      process.stdout.write(reconnectNotification + "\n");
+    }
+  });
+
+  ws.on("message", (data) => {
+    const raw = decodeMessageData(data);
+    // stdout is protocol channel: ONLY write payload lines
+    process.stdout.write(raw + "\n");
+  });
+
+  ws.on("pong", () => {
+    // Heartbeat response received — connection is alive
+    if (pongTimer) { clearTimeout(pongTimer); pongTimer = null; }
+  });
+
+  ws.once("close", (code, reason) => {
+    stopHeartbeat();
+    if (closed || exiting) return;
+    const why = reason ? ` reason=${reason}` : "";
+    // If connection closes before we ever opened, keep retrying until timeout.
+    if (!opened) {
+      setTimeout(connect, Math.min(100 * connectAttempt, 500));
+      return;
+    }
+    // Post-open close — attempt reconnection with backoff
+    scheduleReconnect(`WebSocket closed (code=${code}${why})`);
+  });
+
+  ws.once("error", (err) => {
+    if (closed || exiting) return;
+    // Retry during startup; after a successful connection, use reconnect logic.
+    if (!opened) {
+      setTimeout(connect, Math.min(100 * connectAttempt, 500));
+      return;
+    }
+    // Post-open error — attempt reconnection with backoff
+    scheduleReconnect(`WebSocket error: ${err && err.message ? err.message : String(err)}`);
+  });
+}
+
+const rl = readline.createInterface({
+  input: process.stdin,
+  crlfDelay: Infinity,
+});
+
+rl.on("line", (line) => {
+  if (closed || exiting) return;
+  if (!line) return;
+  if (!ws || ws.readyState !== WebSocket.OPEN) {
+    queue.push(line);
+    return;
+  }
+  ws.send(line);
+});
+
+rl.on("close", () => {
+  closed = true;
+  stopHeartbeat();
+  try {
+    if (ws && ws.readyState === WebSocket.OPEN) {
+      ws.close();
+    }
+  } catch {}
+  process.exit(0);
+});
+
+process.on("SIGINT", () => {
+  closed = true;
+  stopHeartbeat();
+  try { if (ws) ws.close(); } catch {}
+  process.exit(0);
+});
+
+process.on("SIGTERM", () => {
+  closed = true;
+  stopHeartbeat();
+  try { if (ws) ws.close(); } catch {}
+  process.exit(0);
+});
+
+connect();

package/server/commands-discovery.ts

@@ -0,0 +1,81 @@
+import { readdir } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+/**
+ * Discover slash commands and skills from the filesystem.
+ * Used to pre-populate session state before system.init arrives from the CLI.
+ *
+ * Commands come from:
+ *   - ~/.claude/commands/*.md  (user-level)
+ *   - {cwd}/.claude/commands/*.md  (project-level)
+ *
+ * Skills come from:
+ *   - ~/.claude/skills/`*`/SKILL.md  (user-level, directory name = slug)
+ *
+ * Returns sorted, deduplicated arrays. Never throws.
+ */
+export async function discoverCommandsAndSkills(cwd?: string): Promise<{
+  slash_commands: string[];
+  skills: string[];
+}> {
+  const commandSet = new Set<string>();
+  const skills: string[] = [];
+
+  const home = homedir();
+
+  // User-level commands: ~/.claude/commands/*.md
+  try {
+    const userCommandsDir = join(home, ".claude", "commands");
+    if (existsSync(userCommandsDir)) {
+      const entries = await readdir(userCommandsDir, { withFileTypes: true });
+      for (const e of entries) {
+        if (e.isFile() && e.name.endsWith(".md")) {
+          commandSet.add(e.name.replace(/\.md$/, ""));
+        }
+      }
+    }
+  } catch {
+    /* gracefully ignore */
+  }
+
+  // Project-level commands: {cwd}/.claude/commands/*.md
+  if (cwd) {
+    try {
+      const projectCommandsDir = join(cwd, ".claude", "commands");
+      if (existsSync(projectCommandsDir)) {
+        const entries = await readdir(projectCommandsDir, { withFileTypes: true });
+        for (const e of entries) {
+          if (e.isFile() && e.name.endsWith(".md")) {
+            commandSet.add(e.name.replace(/\.md$/, ""));
+          }
+        }
+      }
+    } catch {
+      /* gracefully ignore */
+    }
+  }
+
+  // User-level skills: ~/.claude/skills/*/SKILL.md
+  try {
+    const skillsDir = join(home, ".claude", "skills");
+    if (existsSync(skillsDir)) {
+      const entries = await readdir(skillsDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        const skillMdPath = join(skillsDir, entry.name, "SKILL.md");
+        if (existsSync(skillMdPath)) {
+          skills.push(entry.name);
+        }
+      }
+    }
+  } catch {
+    /* gracefully ignore */
+  }
+
+  const slash_commands = Array.from(commandSet).sort();
+  skills.sort();
+
+  return { slash_commands, skills };
+}

package/server/constants.ts

@@ -0,0 +1,7 @@
+export const DEFAULT_PORT_DEV = 3457;
+export const DEFAULT_PORT_PROD = 3456;
+
+// Container port constants — shared between routes.ts and session-creation-service.ts
+export const VSCODE_EDITOR_CONTAINER_PORT = 13337;
+export const CODEX_APP_SERVER_CONTAINER_PORT = Number(process.env.HEYHANK_CODEX_CONTAINER_WS_PORT || process.env.COMPANION_CODEX_CONTAINER_WS_PORT || "4502");
+export const NOVNC_CONTAINER_PORT = 6080;