cybercode-cli 1.0.0

package/LICENSE

@@ -0,0 +1,53 @@
+MIT License
+
+Copyright (c) 2025-2026 webui_codex contributors
+
+This project's agent core (agent_core.py) was developed with reference to the
+GenericAgent project (https://github.com/lsdefine/GenericAgent), which is also
+licensed under the MIT License:
+
+  MIT License
+
+  Copyright (c) 2025 lsdefine
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+
+The HyperFrames skills bundled in the skills/ directory are from the
+HyperFrames project (https://github.com/heygen-com/hyperframes), also MIT
+licensed. See individual skill files for their original copyright notices.
+
+---
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,174 @@
+# webui_codex — Codex-dark Web UI with a Built-in Self-Evolving Agent
+
+A standalone, self-contained web UI + agent framework styled after the
+Codex-dark interface. **No external agent dependency** — the entire agent
+core (LLM client, agent loop, 9 atomic tools, layered memory) ships inside
+`agent_core.py` and runs from a single directory.
+
+![cybercode](https://img.shields.io/badge/npm-cybercode-6b8cff) ![deps](https://img.shields.io/badge/dependencies-stdlib+requests-28c840) ![py](https://img.shields.io/badge/python-3.11%2B-blue) ![license](https://img.shields.io/badge/license-MIT-blue)
+
+## Quick Start
+
+```bash
+npx cybercode
+```
+
+That's it. On first run it:
+1. Finds Python 3.11+ on your system
+2. Installs `requests` if missing
+3. Copies the bundled agent + skills to `~/.cybercode/`
+4. Creates a `mykey.json` template (edit it with your API key)
+5. Starts the web UI and opens your browser
+
+## Attribution & License
+
+The agent core architecture in `agent_core.py` was developed with reference to
+[**GenericAgent**](https://github.com/lsdefine/GenericAgent) by lsdefine
+(MIT License, Copyright © 2025 lsdefine). We gratefully acknowledge the
+GenericAgent project — its ~100-line agent loop, 9-atomic-tool design, and
+layered memory concept directly inspired this implementation.
+
+The bundled HyperFrames skills (`skills/`) originate from
+[**HyperFrames**](https://github.com/heygen-com/hyperframes) by HeyGen
+(MIT License).
+
+See `LICENSE` for the full MIT license text, including the GenericAgent
+copyright notice as required by its license terms.
+
+## What it is
+
+`webui_codex.py` boots a self-contained `Agent` (from `agent_core.py`), serves
+`webui_codex.html` at `/`, and exposes a JSON + SSE API the page talks to.
+The UI keeps the Codex-dark look — blue radial-gradient desktop, traffic-light
+window chrome, dark sidebar with threads + skills, centered *Let's build*
+empty state, pill LLM switcher, rounded composer with Local/Worktree/Cloud
+modes — but every control is wired to the built-in agent.
+
+**Standalone: no GenericAgent dependency.** The agent core (`agent_core.py`)
+is a from-scratch reimplementation that ships in this repo. You do **not** need
+GenericAgent installed. The only runtime dependency is `requests` (for the LLM
+HTTP client); everything else uses the Python stdlib.
+
+## Files
+
+```
+webui-codex/
+├── package.json       # npm package config (bin, files, metadata)
+├── bin/
+│   └── cli.mjs        # Node.js launcher (finds Python, bootstraps, opens browser)
+├── python/
+│   ├── agent_core.py       # Self-contained agent core (LLM client + loop + 9 tools + memory)
+│   ├── webui_codex.py      # stdlib HTTP server + SSE + API
+│   └── webui_codex.html    # Codex-dark UI (single file, no build step)
+├── skills/             # HyperFrames video skills (12 files, from HeyGen)
+├── templates/
+│   └── mykey_template.json  # API key template (auto-copied on first run)
+├── LICENSE             # MIT (includes GenericAgent + HyperFrames copyright notices)
+└── README.md           # This file
+```
+
+## Manual (without npx)
+
+If you prefer to run the Python server directly:
+
+```bash
+# 1. Configure your LLM (any OpenAI-compatible endpoint)
+cat > mykey.json << 'EOF'
+{
+  "llm1": {
+    "apikey": "sk-your-key-here",
+    "apibase": "https://api.openai.com",
+    "model": "gpt-4o",
+    "name": "GPT-4o"
+  }
+}
+EOF
+
+# 2. Install requests (only dependency)
+pip install requests
+
+# 3. Run
+python python/webui_codex.py                 # http://127.0.0.1:18600
+```
+
+## Supported LLM providers
+
+Any OpenAI-compatible chat completions endpoint works:
+- **OpenAI** (GPT-4o, o1, o3, etc.)
+- **DeepSeek**
+- **Kimi / Moonshot**
+- **MiniMax**
+- **Local models** via Ollama, LM Studio, vLLM, etc.
+- **Anthropic Claude** via OpenAI-compatible proxies
+
+## What works
+
+| UI element | Wired to |
+| :--- | :--- |
+| **Composer + send** | `agent.put_task()` → SSE stream of deltas + final `done` |
+| **Stop button / red send toggle** | `agent.abort()` |
+| **New thread** | `/api/new` → clears conversation history |
+| **Thread list (sidebar)** | `/api/sessions` → scans `temp/model_responses/` logs |
+| **Click a thread** | `/api/continue` → restores that session + replays bubbles |
+| **LLM pill + dropdown** | `/api/llm` → `agent.next_llm(idx)` |
+| **Skills panel (sidebar)** | `/api/skills` → lists `memory/` SOPs and skill files |
+| **Suggest tasks** | prefills the autonomous-planning prompt |
+| **Status dot** | `agent.is_running` polled every 4s |
+| **Tool / file refs** | `🛠️ Tool: \`name\`` lines → tool chips; `[FILE:path]` → clickable file chips |
+| **Turn folding** | `**LLM Running (Turn N) ...**` markers → collapsible turn sections |
+| **Make video button** | Injects HyperFrames skill preamble + `/video` command |
+| **Video gallery** | `/api/videos` → scans for rendered `.mp4` files |
+| **Video playback** | `/api/video/<path>` → streams with Range support (seekable) |
+
+## The 9 Atomic Tools
+
+The agent core exposes exactly 9 tools (same design philosophy as GenericAgent):
+
+| Tool | Function |
+| :--- | :--- |
+| `code_run` | Execute Python or shell scripts |
+| `file_read` | Read files with line numbers, keyword search |
+| `file_write` | Create / overwrite / append files |
+| `file_patch` | Patch a unique text block in a file |
+| `web_scan` | Fetch and simplify web pages (urllib-based) |
+| `web_execute_js` | Execute JS in a browser (requires TMWebDriver; degrades gracefully) |
+| `ask_user` | Interrupt to ask the user a question |
+| `update_working_checkpoint` | Short-term working memory notepad |
+| `start_long_term_update` | Distill experience into long-term memory |
+
+## HyperFrames — Built-in Video Generation
+
+The HyperFrames skill pack (12 files) is bundled in `skills/`. Click the
+**Make video** button in the sidebar, or type `/video <description>`. The agent
+reads the bundled skills and uses the `npx hyperframes` CLI to render HTML
+compositions into `.mp4` files. Rendered videos appear in the sidebar gallery
+and can be played inline.
+
+## API Reference
+
+| Method | Path | Description |
+| :--- | :--- | :--- |
+| GET | `/` | The web UI |
+| GET | `/api/status` | Agent status: running, LLM, history |
+| GET | `/api/sessions` | Recoverable sessions (log files) |
+| GET | `/api/skills` | Agent memory/SOP files |
+| GET | `/api/messages?path=...` | Replay messages from a session log |
+| GET | `/api/hyperframes` | List bundled HyperFrames skills |
+| GET | `/api/hyperframes/<name>` | Raw skill markdown |
+| GET | `/api/videos` | Rendered `.mp4` files |
+| GET | `/api/video/<path>` | Stream a video (Range-supported) |
+| POST | `/api/chat` | SSE stream: delta / done / error |
+| POST | `/api/llm` | Switch LLM by index |
+| POST | `/api/stop` | Abort current task |
+| POST | `/api/new` | Start fresh conversation |
+| POST | `/api/continue` | Restore session N |
+| POST | `/api/btw` | Side question (while task runs) |
+
+## License
+
+MIT License — see `LICENSE` for full text.
+
+This project's agent core was developed with reference to
+[GenericAgent](https://github.com/lsdefine/GenericAgent) (MIT, Copyright © 2025
+lsdefine). The GenericAgent copyright notice is included in `LICENSE` as
+required by its license terms. HyperFrames skills are MIT-licensed by HeyGen.

package/bin/cli.mjs

@@ -0,0 +1,314 @@
+#!/usr/bin/env node
+// cybercode CLI launcher — bootstraps a Python env and starts the web UI.
+// Designed for `npx cybercode` one-click usage.
+
+import { spawn, spawnSync, execSync } from "node:child_process";
+import { existsSync, mkdirSync, copyFileSync, readdirSync, statSync, writeFileSync, readFileSync } from "node:fs";
+import { join, dirname, resolve } from "node:path";
+import { homedir, platform } from "node:os";
+import { fileURLToPath } from "node:url";
+import { createRequire } from "node:module";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const require = createRequire(import.meta.url);
+const pkg = require("../package.json");
+
+const COLORS = {
+  reset: "\x1b[0m", bold: "\x1b[1m", dim: "\x1b[2m",
+  green: "\x1b[32m", yellow: "\x1b[33m", blue: "\x1b[34m",
+  red: "\x1b[31m", cyan: "\x1b[36m",
+};
+const c = (color, text) => `${COLORS[color] || ""}${text}${COLORS.reset}`;
+
+// ---- Parse CLI args ----
+function parseArgs() {
+  const args = { port: null, host: "127.0.0.1", dir: null, noBrowser: false, llm: 0, help: false, version: false };
+  const argv = process.argv.slice(2);
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "-h" || a === "--help") args.help = true;
+    else if (a === "-V" || a === "--version") args.version = true;
+    else if (a === "-p" || a === "--port") args.port = parseInt(argv[++i], 10);
+    else if (a === "--host") args.host = argv[++i];
+    else if (a === "--dir") args.dir = argv[++i];
+    else if (a === "--no-browser") args.noBrowser = true;
+    else if (a === "--llm") args.llm = parseInt(argv[++i], 10);
+    else if (a === "--open") args.noBrowser = false;
+  }
+  return args;
+}
+
+function showHelp() {
+  console.log(`
+${c("bold", "cybercode")} ${c("dim", `v${pkg.version}`)} — Codex-dark web UI with a built-in self-evolving agent
+
+${c("bold", "USAGE")}
+  npx cybercode                                # start with defaults
+  npx cybercode --port 8080                    # custom port
+  npx cybercode --host 0.0.0.0                 # listen on all interfaces
+  npx cybercode --no-browser                   # don't auto-open browser
+  npx cybercode --dir ~/my-agent               # custom working directory
+  npx cybercode --llm 1                        # start on 2nd configured LLM
+
+${c("bold", "OPTIONS")}
+  -p, --port <num>     Port (default: auto-find free port near 18600)
+  --host <addr>        Bind address (default: 127.0.0.1)
+  --dir <path>         Working directory (default: ~/.cybercode)
+  --llm <num>          LLM index to start with (default: 0)
+  --no-browser         Don't auto-open the browser
+  -h, --help           Show this help
+  -V, --version        Show version
+
+${c("bold", "FIRST RUN")}
+  On first launch, a ${c("cyan", "mykey.json")} template is created in the working
+  directory. Edit it with your LLM API keys (OpenAI, DeepSeek, etc.), then
+  restart. Any OpenAI-compatible endpoint works.
+
+${c("bold", "ATTRIBUTION")}
+  Agent core inspired by GenericAgent (MIT). HyperFrames skills from HeyGen (MIT).
+  See LICENSE for details.
+`);
+}
+
+// ---- Find Python 3.11+ ----
+function findPython() {
+  const candidates = process.env.WEBUI_CODEX_PYTHON
+    ? [process.env.WEBUI_CODEX_PYTHON]
+    : ["python3", "python3.12", "python3.11", "python"];
+
+  for (const cmd of candidates) {
+    try {
+      const result = spawnSync(cmd, ["--version"], { encoding: "utf-8", timeout: 5000 });
+      const output = (result.stdout || "") + (result.stderr || "");
+      const match = output.match(/Python (\d+)\.(\d+)/);
+      if (match) {
+        const major = parseInt(match[1], 10);
+        const minor = parseInt(match[2], 10);
+        if (major > 3 || (major === 3 && minor >= 11)) {
+          return cmd;
+        }
+      }
+    } catch {}
+  }
+
+  console.error(c("red", "✗ Python 3.11+ not found."));
+  console.error(c("dim", "  Install Python 3.11 or 3.12, or set WEBUI_CODEX_PYTHON env var."));
+  console.error(c("dim", "  Download: https://www.python.org/downloads/"));
+  process.exit(1);
+}
+
+// ---- Find a free port ----
+function findFreePort(preferred) {
+  const start = preferred || 18600;
+  for (let port = start; port <= start + 100; port++) {
+    try {
+      const result = spawnSync("python3", ["-c", `import socket; s=socket.socket(); s.bind(("127.0.0.1",${port})); s.close(); print(${port})`], { encoding: "utf-8", timeout: 3000 });
+      if (result.stdout && result.stdout.trim()) return parseInt(result.stdout.trim(), 10);
+    } catch {}
+  }
+  return start;
+}
+
+// ---- Copy directory recursively ----
+function copyDir(src, dest) {
+  if (!existsSync(dest)) mkdirSync(dest, { recursive: true });
+  for (const entry of readdirSync(src)) {
+    const srcPath = join(src, entry);
+    const destPath = join(dest, entry);
+    const stat = statSync(srcPath);
+    if (stat.isDirectory()) {
+      copyDir(srcPath, destPath);
+    } else {
+      copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+// ---- Ensure requests is installed ----
+function ensureRequests(python) {
+  try {
+    const result = spawnSync(python, ["-c", "import requests; print(requests.__version__)"], { encoding: "utf-8", timeout: 5000 });
+    if (result.status === 0 && result.stdout.trim()) {
+      return; // already installed
+    }
+  } catch {}
+
+  console.log(c("yellow", "→ installing requests..."));
+  try {
+    spawnSync(python, ["-m", "pip", "install", "requests", "--quiet", "--disable-pip-version-check"], { stdio: "inherit", timeout: 60000 });
+  } catch {
+    console.error(c("red", "✗ Failed to install requests. Please run: pip install requests"));
+    process.exit(1);
+  }
+}
+
+// ---- Wait for server ----
+function waitForServer(url, maxRetries = 30) {
+  return new Promise((resolve, reject) => {
+    let retries = 0;
+    const check = () => {
+      import("node:http").then(({ default: http }) => {
+        const req = http.get(url, (res) => {
+          res.resume();
+          if (res.statusCode === 200) resolve();
+          else if (++retries < maxRetries) setTimeout(check, 300);
+          else reject(new Error("server unhealthy"));
+        });
+        req.on("error", () => {
+          if (++retries < maxRetries) setTimeout(check, 300);
+          else reject(new Error("server not responding"));
+        });
+        req.setTimeout(2000, () => { req.destroy(); if (++retries < maxRetries) setTimeout(check, 300); else reject(new Error("timeout")); });
+      });
+    };
+    check();
+  });
+}
+
+// ---- Open browser ----
+function openBrowser(url) {
+  const cmds = {
+    darwin: ["open", [url]],
+    win32: ["cmd", ["/c", "start", url]],
+    linux: ["xdg-open", [url]],
+  };
+  const plat = platform();
+  const entry = cmds[plat] || cmds.linux;
+  try {
+    spawn(entry[0], entry[1], { detached: true, stdio: "ignore" }).unref();
+  } catch {}
+}
+
+// ---- Main ----
+async function main() {
+  const args = parseArgs();
+
+  if (args.help) { showHelp(); process.exit(0); }
+  if (args.version) { console.log(pkg.version); process.exit(0); }
+
+  const python = findPython();
+  const workDir = resolve(args.dir || join(homedir(), ".cybercode"));
+
+  // Create working directory
+  if (!existsSync(workDir)) mkdirSync(workDir, { recursive: true });
+
+  // Version stamp — re-copy files if package version changed
+  const stampPath = join(workDir, ".version");
+  const currentVersion = pkg.version;
+  let needsCopy = true;
+  if (existsSync(stampPath)) {
+    const stamped = readFileSync(stampPath, "utf-8").trim();
+    if (stamped === currentVersion) needsCopy = false;
+  }
+
+  // Copy bundled files
+  const bundledPython = join(__dirname, "..", "python");
+  const bundledSkills = join(__dirname, "..", "skills");
+
+  if (needsCopy) {
+    if (existsSync(bundledPython)) copyDir(bundledPython, workDir);
+    if (existsSync(bundledSkills)) copyDir(bundledSkills, join(workDir, "skills"));
+    writeFileSync(stampPath, currentVersion, "utf-8");
+  }
+
+  // Create mykey.json from template if not exists
+  const mykeyPath = join(workDir, "mykey.json");
+  if (!existsSync(mykeyPath)) {
+    const templatePath = join(__dirname, "..", "templates", "mykey_template.json");
+    if (existsSync(templatePath)) {
+      copyFileSync(templatePath, mykeyPath);
+    } else {
+      writeFileSync(mykeyPath, JSON.stringify({
+        llm1: { apikey: "sk-YOUR-KEY", apibase: "https://api.openai.com", model: "gpt-4o", name: "GPT-4o" }
+      }, null, 2));
+    }
+  }
+
+  // Check if mykey.json has been configured
+  let configured = false;
+  try {
+    const mykey = JSON.parse(readFileSync(mykeyPath, "utf-8"));
+    configured = Object.values(mykey).some(v => v.apikey && !v.apikey.includes("YOUR-"));
+  } catch {}
+
+  // Ensure requests
+  ensureRequests(python);
+
+  // Find port
+  const port = args.port || findFreePort(18600);
+  const url = `http://${args.host}:${port}`;
+
+  // Banner
+  console.log();
+  console.log(`  ${c("bold", c("blue", "╭─────────────────────────────────────────────────╮"))}`);
+  console.log(`  ${c("bold", c("blue", "│"))}  ${c("bold", "cybercode")} ${c("dim", `v${currentVersion}`)}                              ${c("bold", c("blue", "│"))}`);
+  console.log(`  ${c("bold", c("blue", "│"))}  ${c("dim", "working dir:")} ${workDir.padEnd(34).slice(0, 34)} ${c("bold", c("blue", "│"))}`);
+  console.log(`  ${c("bold", c("blue", "│"))}  ${c("green", `▶ ${url}`)}${" ".repeat(Math.max(0, 33 - url.length))} ${c("bold", c("blue", "│"))}`);
+  if (!configured) {
+    console.log(`  ${c("bold", c("blue", "│"))}  ${c("yellow", "⚠ edit mykey.json to add your API key")}       ${c("bold", c("blue", "│"))}`);
+  }
+  console.log(`  ${c("bold", c("blue", "╰─────────────────────────────────────────────────╯"))}`);
+  console.log();
+
+  if (!configured) {
+    console.log(c("yellow", `  ⚠ mykey.json not configured yet.`));
+    console.log(c("dim", `    Edit: ${mykeyPath}`));
+    console.log(c("dim", `    Add your OpenAI-compatible API key, then restart.`));
+    console.log(c("dim", `    Or run: nano ${mykeyPath}`));
+    console.log(c("dim", `    The UI will still load and show a setup banner.`));
+    console.log();
+  }
+
+  // Launch Python server
+  const pyArgs = [
+    join(workDir, "webui_codex.py"),
+    "--port", String(port),
+    "--host", args.host,
+    "--llm_no", String(args.llm),
+  ];
+
+  const child = spawn(python, pyArgs, {
+    cwd: workDir,
+    stdio: ["ignore", "pipe", "pipe"],
+    env: { ...process.env, PYTHONUNBUFFERED: "1" },
+  });
+
+  // Pipe server output
+  child.stdout.on("data", (data) => process.stdout.write(data));
+  child.stderr.on("data", (data) => process.stderr.write(c("dim", data.toString())));
+
+  child.on("error", (err) => {
+    console.error(c("red", `✗ Failed to start: ${err.message}`));
+    process.exit(1);
+  });
+
+  child.on("exit", (code) => {
+    process.exit(code || 0);
+  });
+
+  // Wait for server, then open browser
+  if (!args.noBrowser) {
+    try {
+      await waitForServer(`${url}/api/status`, 40);
+      openBrowser(url);
+    } catch {
+      // Server might still be starting; the user can open manually
+      console.log(c("dim", `  (browser auto-open skipped — open ${url} manually)`));
+    }
+  }
+
+  // Handle Ctrl+C
+  process.on("SIGINT", () => {
+    child.kill("SIGINT");
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    child.kill("SIGTERM");
+    process.exit(0);
+  });
+}
+
+main().catch((err) => {
+  console.error(c("red", `✗ ${err.message}`));
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "cybercode-cli",
+  "version": "1.0.0",
+  "description": "Codex-dark web UI with a built-in self-evolving agent + HyperFrames video skills",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "bin": {
+    "cybercode": "bin/cli.mjs"
+  },
+  "files": [
+    "bin/",
+    "python/",
+    "skills/",
+    "templates/",
+    "LICENSE",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "agent",
+    "ai",
+    "llm",
+    "codex",
+    "web-ui",
+    "automation",
+    "self-evolving",
+    "hyperframes",
+    "video-generation"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": ""
+  },
+  "homepage": "",
+  "scripts": {
+    "start": "node bin/cli.mjs",
+    "prepublishOnly": "node -e \"console.log('Publishing cybercode...')\""
+  }
+}