mini-opti-bridge 0.1.0

package/README.md

@@ -0,0 +1,16 @@
+# mini-opti-bridge
+
+One-command bridge bootstrap for the Mini Opti Codex dashboard.
+
+## Usage
+
+```bash
+npx mini-opti-bridge@latest https://mini-opti.vercel.app <registrationKey>
+pnpm dlx mini-opti-bridge@latest https://mini-opti.vercel.app <registrationKey>
+```
+
+Optional named node:
+
+```bash
+npx mini-opti-bridge@latest https://mini-opti.vercel.app <registrationKey> my-node local
+```

package/cli.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "./dist/cli.js";

package/dist/cli.js

@@ -0,0 +1,232 @@
+#!/usr/bin/env node
+
+// src/run.ts
+import os from "os";
+import process2 from "process";
+import { readFile, writeFile } from "fs/promises";
+
+// ../connectors/src/bridge/bootstrap.ts
+var normalizePlatform = (platform) => {
+  if (platform === "win32") return "windows";
+  if (platform === "darwin") return "macos";
+  return platform;
+};
+var defaultNodeLabel = (input) => `${input.hostname}-${normalizePlatform(input.platform)}`;
+var readPollMs = (value) => {
+  const parsed = Number(value ?? "4000");
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : 4e3;
+};
+var parseBridgeBootstrap = (input) => {
+  const env = input.env ?? {};
+  return {
+    serverUrl: input.argv[3] ?? env.MINI_OPTI_SERVER_URL ?? "",
+    key: input.argv[4] ?? env.MINI_OPTI_REGISTRATION_KEY ?? "",
+    label: input.argv[5] ?? env.MINI_OPTI_NODE_LABEL ?? defaultNodeLabel({ hostname: input.hostname, platform: input.platform }),
+    kind: input.argv[6] ?? env.MINI_OPTI_NODE_KIND ?? "local",
+    pollMs: readPollMs(env.MINI_OPTI_POLL_MS)
+  };
+};
+
+// ../connectors/src/codex/app-server-client.ts
+import { spawn } from "child_process";
+import readline from "readline";
+var CodexAppServerClient = class {
+  proc = null;
+  counter = 0;
+  pending = /* @__PURE__ */ new Map();
+  async start() {
+    if (this.proc) return;
+    this.proc = spawn("codex", ["app-server"], { stdio: ["pipe", "pipe", "inherit"] });
+    const rl = readline.createInterface({ input: this.proc.stdout });
+    rl.on("line", (line) => this.onMessage(JSON.parse(line)));
+    await this.request("initialize", {
+      clientInfo: { name: "mini-opti-bridge", title: "Mini Opti Bridge", version: "0.1.0" }
+    });
+    this.notify("initialized", {});
+  }
+  async listThreads() {
+    const data = [];
+    let cursor = null;
+    do {
+      const result = await this.request("thread/list", {
+        cursor,
+        limit: 100,
+        sortKey: "updated_at"
+      });
+      data.push(...result.data ?? []);
+      cursor = result.nextCursor ?? null;
+    } while (cursor);
+    return data;
+  }
+  async readThread(threadId) {
+    const result = await this.request("thread/read", { threadId, includeTurns: true });
+    return result.thread;
+  }
+  async interrupt(threadId, turnId) {
+    return this.request("turn/interrupt", { threadId, turnId });
+  }
+  onMessage(message) {
+    if (typeof message.id === "number") {
+      this.pending.get(message.id)?.(message);
+      this.pending.delete(message.id);
+    }
+  }
+  notify(method, params) {
+    this.proc?.stdin.write(`${JSON.stringify({ method, params })}
+`);
+  }
+  request(method, params) {
+    return new Promise((resolve, reject) => {
+      const id = ++this.counter;
+      this.pending.set(id, (message) => {
+        if (message.error) reject(new Error(message.error.message));
+        else resolve(message.result);
+      });
+      this.proc?.stdin.write(`${JSON.stringify({ method, id, params })}
+`);
+    });
+  }
+};
+
+// ../connectors/src/codex/normalize.ts
+var mapContent = (content = []) => content.map((item) => item.text ?? "").join("\n").trim();
+var normalizeLog = (thread) => (thread.turns ?? []).flatMap(
+  (turn) => (turn.items ?? []).flatMap((item) => {
+    if (item.type === "userMessage") {
+      return [{ role: "user", text: mapContent(item.content), turnId: turn.id, timestamp: Date.now() }];
+    }
+    if (item.type === "agentMessage") {
+      return [{ role: "assistant", text: item.text ?? "", turnId: turn.id, timestamp: Date.now() }];
+    }
+    return [];
+  })
+);
+var normalizeSession = (thread, log = []) => ({
+  id: thread.id,
+  name: thread.name ?? "Untitled session",
+  preview: thread.preview ?? "",
+  status: thread.status?.type ?? "notLoaded",
+  createdAt: thread.createdAt ?? 0,
+  updatedAt: thread.updatedAt ?? thread.createdAt ?? 0,
+  modelProvider: thread.modelProvider ?? "openai",
+  log
+});
+
+// ../connectors/src/codex/sdk-client.ts
+var sendMessageToThread = async (threadId, prompt) => {
+  const { Codex } = await import("@openai/codex-sdk");
+  const codex = new Codex();
+  const thread = codex.resumeThread(threadId);
+  return thread.run(prompt);
+};
+
+// src/args.ts
+var normalizeBridgeArgv = (argv) => {
+  const command = argv[2];
+  if (command === "register" || command === "serve" || command === "up") return argv;
+  return [argv[0] ?? "node", argv[1] ?? "mini-opti-bridge", "up", ...argv.slice(2)];
+};
+
+// src/run.ts
+var configPath = ".codex-bridge.json";
+var readConfig = async () => JSON.parse(await readFile(configPath, "utf8"));
+var saveConfig = async (next) => {
+  await writeFile(configPath, JSON.stringify(next, null, 2), "utf8");
+};
+var postJson = async (serverUrl, pathname, body) => {
+  const response = await fetch(new URL(pathname, serverUrl), {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(body)
+  });
+  const text = await response.text();
+  if (!response.ok) throw new Error(text || `${response.status} ${response.statusText}`);
+  return text ? JSON.parse(text) : {};
+};
+var readBootstrap = (argv) => parseBridgeBootstrap({
+  argv: normalizeBridgeArgv(argv),
+  env: process2.env,
+  hostname: os.hostname(),
+  platform: process2.platform
+});
+var register = async (bootstrap) => {
+  const node = await postJson(bootstrap.serverUrl, "/api/bridges/register", {
+    key: bootstrap.key,
+    label: bootstrap.label,
+    kind: bootstrap.kind,
+    cwd: process2.cwd()
+  });
+  const next = { ...node, serverUrl: bootstrap.serverUrl, pollMs: bootstrap.pollMs };
+  await saveConfig(next);
+  console.log(`registered ${next.nodeId}`);
+  return next;
+};
+var loadOrRegister = async (argv) => {
+  try {
+    return await readConfig();
+  } catch {
+    const bootstrap = readBootstrap(argv);
+    if (!bootstrap.serverUrl || !bootstrap.key) {
+      throw new Error("Usage: mini-opti-bridge [up] <serverUrl> <registrationKey> [label] [local|remote]");
+    }
+    return register(bootstrap);
+  }
+};
+var completeCommand = async (config, client, command) => {
+  if (!command.sessionId) return;
+  if (command.type === "send-message") {
+    await sendMessageToThread(command.sessionId, command.payload?.text ?? "");
+  }
+  if (command.type === "send-message" || command.type === "refresh-log") {
+    const fullThread = await client.readThread(command.sessionId);
+    const log = normalizeLog(fullThread).map((item) => `${item.role}: ${item.text}`).join("\n\n");
+    await postJson(config.serverUrl, "/api/bridges/commands/complete", {
+      commandId: command.id,
+      status: "completed",
+      result: command.type === "send-message" ? "message delivered" : "log refreshed",
+      log
+    });
+  }
+};
+var syncOnce = async (config, client) => {
+  const threads = await client.listThreads();
+  const sessions = threads.map((thread) => normalizeSession(thread));
+  const beat = await postJson(config.serverUrl, "/api/bridges/heartbeat", {
+    nodeId: config.nodeId,
+    bridgeToken: config.bridgeToken,
+    sessions
+  });
+  for (const command of beat.commands ?? []) await completeCommand(config, client, command);
+};
+var serve = async (argv) => {
+  const config = await loadOrRegister(argv);
+  const client = new CodexAppServerClient();
+  await client.start();
+  await syncOnce(config, client);
+  setInterval(() => {
+    syncOnce(config, client).catch((error) => console.error(error));
+  }, config.pollMs);
+};
+var runBridgeCli = async (argv = process2.argv) => {
+  const normalizedArgv = normalizeBridgeArgv(argv);
+  const command = normalizedArgv[2];
+  if (command === "register") {
+    const bootstrap = readBootstrap(normalizedArgv);
+    if (!bootstrap.serverUrl || !bootstrap.key) {
+      throw new Error("Usage: mini-opti-bridge register <serverUrl> <registrationKey> [label] [local|remote]");
+    }
+    await register(bootstrap);
+    return;
+  }
+  if (command === "serve" || command === "up") {
+    await serve(normalizedArgv);
+    return;
+  }
+  throw new Error("Usage: mini-opti-bridge [up] <serverUrl> <registrationKey> [label] [local|remote]");
+};
+
+// src/cli.ts
+runBridgeCli().catch((error) => {
+  console.error(error instanceof Error ? error.message : error);
+  process.exitCode = 1;
+});

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "mini-opti-bridge",
+  "version": "0.1.0",
+  "description": "One-command Codex bridge bootstrap for the Mini Opti dashboard",
+  "type": "module",
+  "bin": "cli.js",
+  "files": [
+    "cli.js",
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dimkk/mini-opti.git",
+    "directory": "packages/bridge-cli"
+  },
+  "bugs": {
+    "url": "https://github.com/dimkk/mini-opti/issues"
+  },
+  "homepage": "https://github.com/dimkk/mini-opti/tree/main/packages/bridge-cli",
+  "scripts": {
+    "build": "tsup --config tsup.config.ts",
+    "lint": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run --config ../../vitest.config.ts --passWithNoTests",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  },
+  "dependencies": {
+    "@openai/codex-sdk": "latest"
+  },
+  "devDependencies": {
+    "@mini-opti/core-schemas": "workspace:*"
+  },
+  "keywords": [
+    "codex",
+    "openai",
+    "telegram",
+    "vercel",
+    "bridge"
+  ],
+  "license": "MIT"
+}