@goodtek/vibeops 0.2.0 → 0.3.0

package/dist/lib/plan-codex-responses.js

@@ -0,0 +1,228 @@
+/**
+ * ChatGPT Codex backend (subscription OAuth) — POST /backend-api/codex/responses
+ * with store:false and stream:true (required for ChatGPT OAuth tokens).
+ *
+ * @see https://github.com/openclaw/openclaw/issues/67740 (payload constraints)
+ */
+import { resolveCodexOAuthAccessToken } from "./plan-codex-auth.js";
+const DEFAULT_BASE = "https://chatgpt.com/backend-api/codex";
+/** Base URL for Codex ChatGPT routes (`…/responses`, `…/models`). */
+export function codexResponsesBaseUrl() {
+    return (process.env.VIBEOPS_CODEX_BASE_URL ?? DEFAULT_BASE).replace(/\/$/, "");
+}
+/** ChatGPT-account Codex (`/backend-api/codex/responses`) does not accept API-only codex model ids such as `gpt-5.1-codex`. */
+function codexModel() {
+    return process.env.VIBEOPS_CODEX_MODEL?.trim() || "gpt-5.4";
+}
+function mapChatMessagesToCodexBody(messages) {
+    const systemChunks = [];
+    const input = [];
+    for (const m of messages) {
+        if (m.role === "system") {
+            systemChunks.push(m.content);
+            continue;
+        }
+        if (m.role === "user") {
+            input.push({
+                type: "message",
+                role: "user",
+                content: [{ type: "input_text", text: m.content }],
+            });
+            continue;
+        }
+        if (m.role === "assistant") {
+            input.push({
+                type: "message",
+                role: "assistant",
+                content: [{ type: "output_text", text: m.content }],
+            });
+        }
+    }
+    const instructions = systemChunks.join("\n\n").trim();
+    if (instructions.length === 0) {
+        throw new Error("Codex responses: at least one system message is required.");
+    }
+    return { instructions, input };
+}
+function deltaTextFromEvent(obj) {
+    const d = obj.delta;
+    if (typeof d === "string")
+        return d;
+    if (d && typeof d === "object") {
+        const t = d.text;
+        if (typeof t === "string")
+            return t;
+    }
+    return "";
+}
+/**
+ * Parses SSE from Codex responses stream; accumulates assistant text deltas.
+ */
+export async function readSseTextBody(response) {
+    const body = response.body;
+    if (!body) {
+        const t = await response.text();
+        return t;
+    }
+    const reader = body.getReader();
+    const dec = new TextDecoder();
+    let pending = "";
+    let out = "";
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        pending += dec.decode(value, { stream: true });
+        let sep;
+        while ((sep = pending.indexOf("\n\n")) >= 0) {
+            const block = pending.slice(0, sep);
+            pending = pending.slice(sep + 2);
+            for (const line of block.split("\n")) {
+                const trimmed = line.trim();
+                if (!trimmed.startsWith("data:"))
+                    continue;
+                const data = trimmed.slice(5).trim();
+                if (data === "[DONE]")
+                    continue;
+                try {
+                    const j = JSON.parse(data);
+                    const typ = String(j.type ?? "");
+                    if (typ === "response.output_text.delta" || typ.endsWith(".output_text.delta")) {
+                        out += deltaTextFromEvent(j);
+                    }
+                    if (typ === "response.completed" || typ === "response.done") {
+                        const resp = j.response;
+                        if (resp && typeof resp === "object") {
+                            const output = resp.output;
+                            if (Array.isArray(output)) {
+                                for (const item of output) {
+                                    if (!item || typeof item !== "object")
+                                        continue;
+                                    const content = item.content;
+                                    if (!Array.isArray(content))
+                                        continue;
+                                    for (const c of content) {
+                                        if (!c || typeof c !== "object")
+                                            continue;
+                                        const o = c;
+                                        if (o.type === "output_text" && typeof o.text === "string") {
+                                            out += o.text;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                catch {
+                    /* ignore malformed SSE JSON */
+                }
+            }
+        }
+    }
+    pending += dec.decode();
+    if (pending.trim().length > 0) {
+        for (const line of pending.split("\n")) {
+            const trimmed = line.trim();
+            if (!trimmed.startsWith("data:"))
+                continue;
+            const data = trimmed.slice(5).trim();
+            if (data === "[DONE]")
+                continue;
+            try {
+                const j = JSON.parse(data);
+                const typ = String(j.type ?? "");
+                if (typ === "response.output_text.delta" || typ.endsWith(".output_text.delta")) {
+                    out += deltaTextFromEvent(j);
+                }
+            }
+            catch {
+                /* ignore */
+            }
+        }
+    }
+    return out.trim();
+}
+async function postCodexResponses(body) {
+    const { accessToken } = await resolveCodexOAuthAccessToken();
+    const url = `${codexResponsesBaseUrl()}/responses`;
+    return fetch(url, {
+        method: "POST",
+        headers: {
+            Authorization: `Bearer ${accessToken}`,
+            "Content-Type": "application/json",
+            Accept: "text/event-stream",
+            "OpenAI-Beta": "responses=v1",
+        },
+        body: JSON.stringify(body),
+    });
+}
+/**
+ * One planning model turn via Codex (ChatGPT OAuth). Returns raw assistant text
+ * (expected to be a single JSON object per VibeOps protocol).
+ */
+export async function codexOAuthPlanCompletion(messages, options) {
+    const { instructions, input } = mapChatMessagesToCodexBody(messages);
+    const model = options?.model?.trim() || codexModel();
+    const withJsonFormat = () => ({
+        model,
+        instructions,
+        input,
+        store: false,
+        stream: true,
+        text: {
+            format: {
+                type: "json_object",
+            },
+        },
+    });
+    const minimal = () => ({
+        model,
+        instructions,
+        input,
+        store: false,
+        stream: true,
+    });
+    let res = await postCodexResponses(withJsonFormat());
+    if (!res.ok) {
+        const errText = await res.text().catch(() => "");
+        if (res.status === 400 && /unknown|unsupported|text|format|parameter/i.test(errText)) {
+            res = await postCodexResponses(minimal());
+            if (!res.ok) {
+                const err2 = await res.text().catch(() => "");
+                throw new Error(`Codex responses HTTP ${res.status}: ${err2.slice(0, 500)}`);
+            }
+        }
+        else {
+            throw new Error(`Codex responses HTTP ${res.status}: ${errText.slice(0, 500)}`);
+        }
+    }
+    const text = await readSseTextBody(res);
+    if (text.length === 0) {
+        throw new Error("Codex responses stream produced empty text.");
+    }
+    return text;
+}
+/**
+ * One assistant turn as free markdown (no JSON schema) — used for planner apply.
+ */
+export async function codexOAuthTextCompletion(messages, options) {
+    const { instructions, input } = mapChatMessagesToCodexBody(messages);
+    const model = options?.model?.trim() || codexModel();
+    const res = await postCodexResponses({
+        model,
+        instructions,
+        input,
+        store: false,
+        stream: true,
+    });
+    if (!res.ok) {
+        const errText = await res.text().catch(() => "");
+        throw new Error(`Codex responses HTTP ${res.status}: ${errText.slice(0, 500)}`);
+    }
+    const text = await readSseTextBody(res);
+    if (text.length === 0) {
+        throw new Error("Codex responses stream produced empty text.");
+    }
+    return text;
+}

package/dist/lib/plan-llm-cursor-agent.js

@@ -0,0 +1,59 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+function agentBin() {
+    return process.env.VIBEOPS_CURSOR_AGENT_BIN?.trim() || "agent";
+}
+/**
+ * Runs Cursor Agent CLI in print mode with JSON output and plan mode.
+ * @see https://cursor.com/docs/cli/reference/parameters
+ */
+export async function cursorAgentPrint(params) {
+    const command = agentBin();
+    const argv = [
+        "--print",
+        "--output-format",
+        "json",
+        "--plan",
+        "--workspace",
+        params.cwd,
+        ...(params.model?.trim() ? ["--model", params.model.trim()] : []),
+        "--trust",
+        params.prompt,
+    ];
+    try {
+        const { stdout, stderr } = await execFileAsync(command, argv, {
+            cwd: params.cwd,
+            maxBuffer: 16 * 1024 * 1024,
+            env: process.env,
+        });
+        const combined = `${stdout}${stderr}`.trim();
+        return combined.length > 0 ? combined : stdout;
+    }
+    catch (e) {
+        const err = e;
+        const msg = [err.stderr, err.message].filter(Boolean).join("\n").trim();
+        throw new Error(msg.length > 0 ? msg : `${command} --print failed`);
+    }
+}
+/**
+ * Parses `agent --print --output-format json` stdout.
+ * Shape may be `{ "result": "..." }` or nested — try common keys then raw.
+ */
+export function extractAgentAssistantText(rawStdout) {
+    const trimmed = rawStdout.trim();
+    try {
+        const j = JSON.parse(trimmed);
+        for (const key of ["result", "response", "output", "text", "message", "content"]) {
+            const v = j[key];
+            if (typeof v === "string" && v.trim().length > 0)
+                return v.trim();
+        }
+        if (typeof j.assistant === "string")
+            return j.assistant.trim();
+    }
+    catch {
+        /* fall through */
+    }
+    return trimmed;
+}

package/dist/lib/plan-llm-detect.js

@@ -0,0 +1,74 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+/**
+ * Confirms `OPENAI_API_KEY` is set and accepted by the OpenAI API (lightweight).
+ */
+export async function probeOpenAiApiKey() {
+    const key = process.env.OPENAI_API_KEY?.trim();
+    if (!key || key.length === 0) {
+        return { ok: false, reason: "OPENAI_API_KEY is not set." };
+    }
+    try {
+        const res = await fetch("https://api.openai.com/v1/models?limit=1", {
+            method: "GET",
+            headers: {
+                Authorization: `Bearer ${key}`,
+            },
+        });
+        if (!res.ok) {
+            const body = await res.text().catch(() => "");
+            return {
+                ok: false,
+                reason: `OpenAI API returned ${res.status}. ${body.slice(0, 200)}`,
+            };
+        }
+        return { ok: true };
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        return { ok: false, reason: `Network error: ${msg}` };
+    }
+}
+function agentBin() {
+    return process.env.VIBEOPS_CURSOR_AGENT_BIN?.trim() || "agent";
+}
+/**
+ * Checks that the Cursor Agent CLI is on PATH and `agent status` succeeds.
+ */
+export async function probeCursorAgentCli(cwd) {
+    const command = agentBin();
+    try {
+        const { stdout, stderr } = await execFileAsync(command, ["status"], {
+            cwd,
+            maxBuffer: 2 * 1024 * 1024,
+            env: process.env,
+        });
+        const out = `${stdout}\n${stderr}`.trim();
+        if (/not\s+logged\s+in|login\s+required|unauthorized|no\s+auth/i.test(out)) {
+            return {
+                ok: false,
+                command,
+                stdout: out,
+                reason: "Cursor Agent CLI is installed but not authenticated.",
+            };
+        }
+        return { ok: true, command, stdout: out };
+    }
+    catch (e) {
+        const err = e;
+        if (err.code === "ENOENT") {
+            return {
+                ok: false,
+                command,
+                reason: `Command "${command}" not found on PATH. Install from https://cursor.com/docs/cli`,
+            };
+        }
+        const msg = [err.stderr, err.message].filter(Boolean).join(" ").trim();
+        return {
+            ok: false,
+            command,
+            reason: msg.length > 0 ? msg : "agent status failed",
+        };
+    }
+}

package/dist/lib/plan-llm-models.js

@@ -0,0 +1,237 @@
+/**
+ * Interactive `vibeops plan`: discover model ids from the active provider
+ * (OpenAI / Codex ChatGPT OAuth / Cursor Agent CLI), then let the user pick.
+ */
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { resolveCodexOAuthAccessToken } from "./plan-codex-auth.js";
+import { codexResponsesBaseUrl } from "./plan-codex-responses.js";
+import { askInput, askSelect } from "./inquirer-helpers.js";
+import { dim, log, yellow } from "./logger.js";
+const execFileAsync = promisify(execFile);
+const DEFAULT_PICK_LABEL = "(Use environment / VibeOps default)";
+const MAX_OPENAI_MODELS = 100;
+const MAX_CODEX_MODELS = 200;
+const MAX_SELECT_CHOICES = 120;
+/** Codex `GET /models` requires `client_version` (same query as official Codex CLI). */
+const DEFAULT_CODEX_CLIENT_VERSION = "0.130.0";
+async function resolveCodexClientVersion() {
+    const env = process.env.VIBEOPS_CODEX_CLIENT_VERSION?.trim();
+    if (env)
+        return env;
+    try {
+        const { stdout } = await execFileAsync("codex", ["--version"], {
+            maxBuffer: 64 * 1024,
+            env: process.env,
+            timeout: 4000,
+        });
+        const line = stdout
+            .trim()
+            .split(/\r?\n/)
+            .find((l) => l.trim().length > 0);
+        if (line) {
+            const m = /(\d+\.\d+\.\d+(?:-[a-zA-Z0-9.]+)?)/.exec(line);
+            if (m?.[1])
+                return m[1];
+        }
+    }
+    catch {
+        /* codex not on PATH */
+    }
+    return DEFAULT_CODEX_CLIENT_VERSION;
+}
+function agentBin() {
+    return process.env.VIBEOPS_CURSOR_AGENT_BIN?.trim() || "agent";
+}
+/** Best-effort parse for Codex `/models` and similar JSON shapes. */
+export function extractModelIdsFromUnknownJson(json) {
+    const ids = [];
+    const fromArray = (arr) => {
+        for (const item of arr) {
+            if (typeof item === "string" && item.trim().length > 0) {
+                ids.push(item.trim());
+                continue;
+            }
+            if (!item || typeof item !== "object" || Array.isArray(item))
+                continue;
+            const o = item;
+            for (const k of ["id", "slug", "model", "name", "model_id"]) {
+                const v = o[k];
+                if (typeof v === "string" && v.trim().length > 0) {
+                    ids.push(v.trim());
+                    break;
+                }
+            }
+        }
+    };
+    if (Array.isArray(json)) {
+        fromArray(json);
+    }
+    else if (json && typeof json === "object") {
+        const o = json;
+        for (const key of ["data", "models", "items", "results"]) {
+            const a = o[key];
+            if (Array.isArray(a))
+                fromArray(a);
+        }
+    }
+    return [...new Set(ids)].sort((a, b) => a.localeCompare(b));
+}
+function isReasonableOpenAiChatModel(id) {
+    const x = id.toLowerCase();
+    if (!x)
+        return false;
+    if (/embedding|embed|whisper|tts|realtime|transcribe|audio-in|audio-out|image|dall-e|moderation|davinci|babbage|ada-|text-search|code-search|omni-moderation/.test(x)) {
+        return false;
+    }
+    return /^gpt-|^o[0-9]|^chatgpt-/.test(x);
+}
+function rankOpenAiPlanModel(id) {
+    if (/gpt-5\.[45]/.test(id))
+        return 1000;
+    if (/gpt-5/.test(id))
+        return 900;
+    if (/gpt-4o/.test(id))
+        return 800;
+    if (/gpt-4/.test(id))
+        return 700;
+    if (/^o[0-9]/.test(id))
+        return 650;
+    if (/gpt-3/.test(id))
+        return 300;
+    return 100;
+}
+export async function fetchOpenAiPlatformModelIds() {
+    const key = process.env.OPENAI_API_KEY?.trim();
+    if (!key) {
+        throw new Error("OPENAI_API_KEY is not set.");
+    }
+    const res = await fetch("https://api.openai.com/v1/models", {
+        headers: { Authorization: `Bearer ${key}` },
+    });
+    const text = await res.text();
+    if (!res.ok) {
+        throw new Error(`OpenAI models HTTP ${res.status}: ${text.slice(0, 400)}`);
+    }
+    const j = JSON.parse(text);
+    const raw = (j.data ?? []).map((x) => x.id).filter((x) => typeof x === "string");
+    const filtered = raw.filter(isReasonableOpenAiChatModel);
+    const sorted = [...new Set(filtered)].sort((a, b) => {
+        const d = rankOpenAiPlanModel(b) - rankOpenAiPlanModel(a);
+        return d !== 0 ? d : a.localeCompare(b);
+    });
+    return sorted.slice(0, MAX_OPENAI_MODELS);
+}
+export async function fetchCodexOAuthModelIds() {
+    const { accessToken } = await resolveCodexOAuthAccessToken();
+    const clientVersion = await resolveCodexClientVersion();
+    const base = codexResponsesBaseUrl();
+    const url = new URL(`${base}/models`);
+    url.searchParams.set("client_version", clientVersion);
+    const res = await fetch(url.toString(), {
+        method: "GET",
+        headers: {
+            Authorization: `Bearer ${accessToken}`,
+            Accept: "application/json",
+        },
+    });
+    const text = await res.text();
+    if (!res.ok) {
+        throw new Error(`Codex models HTTP ${res.status}: ${text.slice(0, 400)}`);
+    }
+    let j;
+    try {
+        j = JSON.parse(text);
+    }
+    catch {
+        throw new Error("Codex models response was not JSON.");
+    }
+    const ids = extractModelIdsFromUnknownJson(j);
+    if (ids.length === 0) {
+        throw new Error("Codex models response contained no model ids.");
+    }
+    return ids.slice(0, MAX_CODEX_MODELS);
+}
+/** Parses `agent models` / `agent --list-models` human-readable listing. */
+export function parseAgentModelsStdout(text) {
+    const rows = [];
+    for (const line of text.split("\n")) {
+        const trimmed = line.trim();
+        const m = /^([a-zA-Z0-9._-]+)\s+-\s+(.+)$/.exec(trimmed);
+        if (!m)
+            continue;
+        const id = m[1];
+        const rest = m[2].trim();
+        if (id === "Available")
+            continue;
+        rows.push({ id, label: `${id} — ${rest}` });
+    }
+    return rows;
+}
+export async function fetchCursorAgentModelRows(cwd) {
+    const command = agentBin();
+    const { stdout, stderr } = await execFileAsync(command, ["models"], {
+        cwd,
+        maxBuffer: 4 * 1024 * 1024,
+        env: process.env,
+    });
+    const rows = parseAgentModelsStdout(`${stdout}\n${stderr}`);
+    if (rows.length === 0) {
+        throw new Error(`${command} models produced no parseable lines.`);
+    }
+    return rows;
+}
+async function pickFromLabels(rows, message) {
+    const cap = MAX_SELECT_CHOICES - 1;
+    const slice = rows.slice(0, cap);
+    if (rows.length > cap) {
+        log.info(dim(`Showing first ${cap} of ${rows.length} models.`));
+    }
+    const choices = [...slice.map((r) => r.label), DEFAULT_PICK_LABEL];
+    const picked = await askSelect({
+        message,
+        nonInteractive: false,
+        choices,
+        default: slice[0]?.label ?? DEFAULT_PICK_LABEL,
+    });
+    if (picked === DEFAULT_PICK_LABEL)
+        return undefined;
+    const hit = slice.find((r) => r.label === picked);
+    return hit?.value;
+}
+/**
+ * After the user picks a provider (and auth exists), query the provider for
+ * model ids and ask which one to use. Returns `undefined` to keep env / built-in defaults.
+ */
+export async function pickPlanExecutionModel(params) {
+    if (!params.interactive)
+        return undefined;
+    log.blank();
+    log.step("Fetching available models from the provider…");
+    try {
+        if (params.provider === "openai") {
+            const ids = await fetchOpenAiPlatformModelIds();
+            const rows = ids.map((id) => ({ value: id, label: id }));
+            return await pickFromLabels(rows, "Choose OpenAI model for planning (↑/↓ · Enter)");
+        }
+        if (params.provider === "codex-oauth") {
+            const ids = await fetchCodexOAuthModelIds();
+            const rows = ids.map((id) => ({ value: id, label: id }));
+            return await pickFromLabels(rows, "Choose Codex (ChatGPT) model for planning (↑/↓ · Enter)");
+        }
+        const rows = await fetchCursorAgentModelRows(params.cwd);
+        return await pickFromLabels(rows.map((r) => ({ value: r.id, label: r.label })), "Choose Cursor Agent model for planning (↑/↓ · Enter)");
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        log.warn(`${yellow("!")} Model list could not be loaded: ${msg}`);
+        log.info(dim("Enter a model id manually, or press Enter for the environment / built-in default."));
+        const typed = await askInput({
+            message: "Model id (optional)",
+            nonInteractive: false,
+            default: "",
+        });
+        const t = typed.trim();
+        return t.length > 0 ? t : undefined;
+    }
+}