@seele00/seele 0.1.60

package/LEGAL.md

@@ -0,0 +1,7 @@
+Legal Disclaimer
+
+Within this source code, the comments in Chinese shall be the original, governing version. Any comment in other languages are for reference only. In the event of any conflict between the Chinese language version comments and other language version comments, the Chinese language version shall prevail.
+
+法律免责声明
+
+关于代码注释部分，中文注释为官方版本，其它语言注释仅做参考。中文注释可能与其它语言注释存在不一致，当中文注释与其它语言注释存在不一致时，请以中文注释为准。

package/README.md

@@ -0,0 +1,76 @@
+# Seele Codex npm Package
+
+This package is the prebuilt Linux x64 Seele service. Node.js 24 LTS and
+npm are required on the target host. npm downloads the production dependencies
+during installation; the target host does not need pnpm, TypeScript, or Vite.
+
+The web output is path-independent. `SEELE_PUBLIC_BASE_PATH` selects the public
+path when the service starts; changing it does not require another build.
+
+## Required Deployment Values
+
+Before installation, confirm all of these values with the package owner or
+target-environment owner. Do not invent or silently default them:
+
+- `SEELE_ROOT`: persistent root containing `.runtime` and `workspaces`.
+- `SEELE_CODEX_HOST`: service listen address.
+- `SEELE_CODEX_PORT`: service listen port.
+- `SEELE_PUBLIC_BASE_PATH`: externally visible path prefix, such as `/`.
+- `SEELE_PROXY`: local no-auth proxy URL consumed by Codex.
+- `SEELE_UPSTREAM_PROXY`: authenticated upstream proxy URL consumed by gost.
+- `SEELE_AUTH_PASSWORD`: initial admin password for a non-loopback listener.
+
+`SEELE_UPSTREAM_PROXY` has the form
+`socks5h://username:password@hostname:port`. Ask the package owner for the
+complete secret value. Do not reconstruct it from the example.
+
+## Install
+
+Keep npm's cache under the persistent Seele root so later installs and upgrades
+can reuse downloaded packages:
+
+```bash
+npm install --global @seele00/seele@latest \
+  --registry=https://registry.npmmirror.com/ \
+  --cache "$SEELE_ROOT/.runtime/npm-cache"
+```
+
+Copy and edit the environment template:
+
+```bash
+cp "$(seele env-example)" "$SEELE_ROOT/seele.env"
+vi "$SEELE_ROOT/seele.env"
+```
+
+On the first installation, prepare the Seele-managed Codex CLI, authenticate
+with a headless device code, and start the service:
+
+```bash
+seele bootstrap \
+  --env "$SEELE_ROOT/seele.env" \
+  --auth device \
+  --start
+```
+
+The command prints a URL and one-time device code. Complete authentication in
+a browser on another machine. No browser is required on the Linux host.
+
+## Start And Upgrade
+
+For normal service starts after bootstrap:
+
+```bash
+seele start --env "$SEELE_ROOT/seele.env"
+```
+
+Upgrade the npm package without rebuilding Seele on the target host:
+
+```bash
+npm install --global @seele00/seele@<new-version> \
+  --registry=https://registry.npmmirror.com/ \
+  --cache "$SEELE_ROOT/.runtime/npm-cache"
+seele start --env "$SEELE_ROOT/seele.env"
+```
+
+Package upgrades do not update an existing Codex CLI. Use Seele's runtime
+settings UI for later Codex CLI updates.

package/bin/seele-codex

@@ -0,0 +1,58 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SOURCE="${BASH_SOURCE[0]}"
+while [ -h "$SOURCE" ]; do
+  SOURCE_DIR="$(cd -P "$(dirname "$SOURCE")" && pwd)"
+  SOURCE="$(readlink "$SOURCE")"
+  case "$SOURCE" in
+    /*) ;;
+    *) SOURCE="$SOURCE_DIR/$SOURCE" ;;
+  esac
+done
+PACKAGE_ROOT="$(cd -P "$(dirname "$SOURCE")/.." && pwd)"
+
+usage() {
+  cat <<'EOF'
+Usage: seele-codex <command> [options]
+
+Commands:
+  bootstrap   Prepare Codex CLI/authentication, then optionally start Seele.
+  start       Start the Seele web and API service.
+  doctor      Check the configured Seele runtime.
+  env-example Print the installed environment-file template path.
+  version     Print the installed Seele package version.
+EOF
+}
+
+COMMAND="${1:-}"
+if [ -n "$COMMAND" ]; then
+  shift
+fi
+
+case "$COMMAND" in
+  bootstrap)
+    exec "$PACKAGE_ROOT/scripts/deploy/bootstrap.sh" --skip-build "$@"
+    ;;
+  start)
+    exec "$PACKAGE_ROOT/scripts/deploy/start.sh" "$@"
+    ;;
+  doctor)
+    export SEELE_CODEX_WEB_DIST="${SEELE_CODEX_WEB_DIST:-$PACKAGE_ROOT/web/dist}"
+    exec node "$PACKAGE_ROOT/server/dist/doctor.js" "$@"
+    ;;
+  env-example)
+    printf '%s\n' "$PACKAGE_ROOT/scripts/deploy/seele.env.example"
+    ;;
+  version|--version|-v)
+    exec node -e 'console.log(require(process.argv[1]).version)' "$PACKAGE_ROOT/package.json"
+    ;;
+  help|--help|-h|"")
+    usage
+    ;;
+  *)
+    echo "Unknown command: $COMMAND" >&2
+    usage >&2
+    exit 1
+    ;;
+esac

package/codex/dist/app-server.js

@@ -0,0 +1,63 @@
+import { CodexRpcClient } from "./rpc-client.js";
+import { StdioCodexTransport } from "./transports/stdio.js";
+export class CodexAppServer {
+    options;
+    transport;
+    rpc;
+    constructor(options) {
+        this.options = options;
+        this.transport = new StdioCodexTransport();
+        this.rpc = new CodexRpcClient(this.transport);
+    }
+    async start() {
+        this.transport.start({
+            codexBin: this.options.codexBin,
+            codexArgs: this.options.codexArgs,
+            cwd: this.options.cwd,
+            env: this.options.env,
+        });
+        await this.rpc.request("initialize", {
+            clientInfo: this.options.clientInfo,
+            capabilities: this.options.capabilities ?? { experimentalApi: true },
+        });
+        this.rpc.notify("initialized", {});
+    }
+    stop() {
+        this.transport.stop();
+    }
+    async startThread(options = {}) {
+        const result = await this.rpc.request("thread/start", options);
+        if (!result.thread?.id) {
+            throw new Error("thread/start did not return a thread id");
+        }
+        return result.thread;
+    }
+    async resumeThread(options) {
+        const result = await this.rpc.request("thread/resume", options);
+        if (!result.thread?.id) {
+            throw new Error("thread/resume did not return a thread id");
+        }
+        return result.thread;
+    }
+    async startTurn(options) {
+        return this.rpc.request("turn/start", options);
+    }
+    async steerTurn(options) {
+        return this.rpc.request("turn/steer", options);
+    }
+    async injectThreadItems(options) {
+        return this.rpc.request("thread/inject_items", options);
+    }
+    async readThread(options) {
+        return this.rpc.request("thread/read", options);
+    }
+    async interruptTurn(options) {
+        return this.rpc.request("turn/interrupt", options);
+    }
+    async listModels(options = {}) {
+        return this.rpc.request("model/list", options);
+    }
+    async readRateLimits() {
+        return this.rpc.request("account/rateLimits/read");
+    }
+}

package/codex/dist/errors.js

@@ -0,0 +1,16 @@
+export class CodexRpcError extends Error {
+    code;
+    data;
+    constructor(error) {
+        super(error.message);
+        this.name = "CodexRpcError";
+        this.code = error.code;
+        this.data = error.data;
+    }
+}
+export class CodexProcessError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "CodexProcessError";
+    }
+}

package/codex/dist/index.js

@@ -0,0 +1,4 @@
+export { CodexAppServer } from "./app-server.js";
+export { CodexRpcClient } from "./rpc-client.js";
+export { StdioCodexTransport } from "./transports/stdio.js";
+export { CodexProcessError, CodexRpcError } from "./errors.js";

package/codex/dist/rpc-client.js

@@ -0,0 +1,96 @@
+import { EventEmitter } from "node:events";
+import { CodexProcessError, CodexRpcError } from "./errors.js";
+export class CodexRpcClient extends EventEmitter {
+    transport;
+    nextId = 1;
+    pending = new Map();
+    constructor(transport) {
+        super();
+        this.transport = transport;
+        this.transport.on("message", (message) => this.handleMessage(message));
+        this.transport.on("stderr", (line) => this.emit("stderr", line));
+        this.transport.on("error", (error) => {
+            this.rejectPending(error);
+            this.emit("error", error);
+        });
+        this.transport.on("exit", (event) => {
+            this.rejectPending(new CodexProcessError(codexExitMessage(event)));
+            this.emit("exit", event);
+        });
+    }
+    request(method, params) {
+        const id = this.nextId++;
+        const message = params === undefined ? { id, method } : { id, method, params };
+        return new Promise((resolve, reject) => {
+            this.pending.set(id, {
+                resolve: (value) => resolve(value),
+                reject,
+            });
+            this.transport.send(message);
+        });
+    }
+    notify(method, params) {
+        const message = params === undefined ? { method } : { method, params };
+        this.transport.send(message);
+    }
+    respond(id, result) {
+        this.transport.send({ id, result });
+    }
+    respondError(id, code, message) {
+        this.transport.send({ id, error: { code, message } });
+    }
+    onNotification(handler) {
+        this.on("notification", handler);
+        return () => this.off("notification", handler);
+    }
+    onRequest(handler) {
+        this.on("request", handler);
+        return () => this.off("request", handler);
+    }
+    handleMessage(message) {
+        if (this.isRequest(message)) {
+            this.emit("request", message);
+            return;
+        }
+        if (this.isResponse(message)) {
+            const pending = this.pending.get(message.id);
+            if (!pending) {
+                this.emit("unmatchedResponse", message);
+                return;
+            }
+            this.pending.delete(message.id);
+            if (message.error) {
+                pending.reject(new CodexRpcError(message.error));
+                return;
+            }
+            pending.resolve(message.result ?? null);
+            return;
+        }
+        if (this.isNotification(message)) {
+            this.emit("notification", message);
+        }
+    }
+    isResponse(message) {
+        return (typeof message.id === "number" &&
+            typeof message.method !== "string");
+    }
+    isRequest(message) {
+        return (typeof message.id === "number" &&
+            typeof message.method === "string");
+    }
+    isNotification(message) {
+        return (typeof message.method === "string" &&
+            typeof message.id !== "number");
+    }
+    rejectPending(error) {
+        const pending = [...this.pending.values()];
+        this.pending.clear();
+        for (const request of pending) {
+            request.reject(error);
+        }
+    }
+}
+function codexExitMessage(event) {
+    const summary = `codex app-server exited: code=${event.code} signal=${event.signal}`;
+    return event.stderr ? `${summary}\n${event.stderr}` : summary;
+}

package/codex/dist/transports/stdio.js

@@ -0,0 +1,81 @@
+import { spawn } from "node:child_process";
+import readline from "node:readline";
+import { EventEmitter } from "node:events";
+import { CodexProcessError } from "../errors.js";
+export class StdioCodexTransport extends EventEmitter {
+    process = null;
+    stderrTail = "";
+    start(options = {}) {
+        if (this.process) {
+            return;
+        }
+        const codexBin = options.codexBin ?? "codex";
+        this.stderrTail = "";
+        const child = spawn(codexBin, [...(options.codexArgs ?? []), "app-server", "--listen", "stdio://"], {
+            cwd: options.cwd,
+            env: { ...process.env, ...options.env },
+            detached: process.platform !== "win32",
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        this.process = child;
+        const stdout = readline.createInterface({ input: child.stdout });
+        stdout.on("line", (line) => {
+            if (!line.trim()) {
+                return;
+            }
+            try {
+                this.emit("message", JSON.parse(line));
+            }
+            catch (error) {
+                this.emit("error", new CodexProcessError(`Failed to parse app-server JSON line: ${error.message}`));
+            }
+        });
+        child.stderr.on("data", (chunk) => {
+            const text = chunk.toString("utf8");
+            this.stderrTail = `${this.stderrTail}${text}`.slice(-8_000);
+            this.emit("stderr", text);
+        });
+        child.on("error", (error) => {
+            this.emit("error", error);
+        });
+        child.on("exit", (code, signal) => {
+            this.process = null;
+            this.emit("exit", {
+                code,
+                signal,
+                stderr: this.stderrTail.trim() || null,
+            });
+        });
+    }
+    send(message) {
+        if (!this.process) {
+            throw new CodexProcessError("codex app-server process is not running");
+        }
+        this.process.stdin.write(`${JSON.stringify(message)}\n`);
+    }
+    stop() {
+        if (!this.process) {
+            return;
+        }
+        const child = this.process;
+        this.process = null;
+        if (process.platform !== "win32" && child.pid) {
+            try {
+                process.kill(-child.pid, "SIGTERM");
+            }
+            catch {
+                child.kill("SIGTERM");
+            }
+            setTimeout(() => {
+                try {
+                    process.kill(-child.pid, "SIGKILL");
+                }
+                catch {
+                    // The process group already exited.
+                }
+            }, 1500).unref();
+            return;
+        }
+        child.kill("SIGTERM");
+    }
+}

package/codex/dist/types.js

@@ -0,0 +1 @@
+export {};

package/codex/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "@seele-codex/codex",
+  "version": "0.1.60",
+  "private": true,
+  "type": "module",
+  "main": "dist/index.js",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js"
+    }
+  }
+}

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@seele00/seele",
+  "version": "0.1.60",
+  "description": "Browser UI and server runtime for Seele Codex",
+  "private": false,
+  "type": "module",
+  "license": "UNLICENSED",
+  "os": [
+    "linux"
+  ],
+  "cpu": [
+    "x64"
+  ],
+  "engines": {
+    "node": ">=24 <25"
+  },
+  "bin": {
+    "seele": "bin/seele-codex",
+    "seele-codex": "bin/seele-codex"
+  },
+  "scripts": {
+    "postinstall": "node scripts/deploy/npm/postinstall.mjs"
+  }
+}