@geteigen/cli 0.0.0-stage → 3.1.0

package/dist/shared/backends/types.d.ts

@@ -0,0 +1,171 @@
+import type { AgentTodoItem, ClarifyingQuestion } from "../events.js";
+import type { ToolIntegrationRef } from "../toolIntegration.js";
+import type { CliCommandCatalog } from "../slashCommands.js";
+/** Backend kind for a room-level agent process. */
+export type AgentBackendKind = "cursor" | "claude-code" | "codex" | "opencode";
+/** Claude Code, Codex, and OpenCode share the local-CLI + Blaxel-sandbox path. */
+export declare const CLI_SANDBOX_BACKENDS: readonly ["claude-code", "codex", "opencode"];
+export type CliSandboxBackendKind = (typeof CLI_SANDBOX_BACKENDS)[number];
+export declare function isCliSandboxBackend(kind: string | null | undefined): kind is CliSandboxBackendKind;
+export declare function parseAgentBackendKind(raw: unknown): AgentBackendKind;
+export declare function backendShortLabel(kind: AgentBackendKind): string;
+/** Git / PR metadata attached to a completed cloud agent run. */
+export interface RunGitInfo {
+    branches: Array<{
+        repoUrl: string;
+        branch?: string;
+        prUrl?: string;
+    }>;
+}
+/** Token use (and cost, when the CLI reports it) for one finished turn. */
+export interface RunUsage {
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens: number;
+    cacheWriteTokens: number;
+    /** Reported by the CLI (Claude Code); absent when it has to be estimated. */
+    costUsd?: number;
+}
+export type { AgentTodoItem, ClarifyingQuestion };
+/**
+ * Normalized agent stream events used internally by Steer.
+ * Subagent events from within a single agent carry `subagent_nested`
+ * and a parent tool-call id — they do NOT create a new Agent row.
+ */
+export type NormalizedAgentEvent = {
+    kind: "session";
+    sessionId: string;
+} | {
+    kind: "assistant_delta";
+    text: string;
+} | {
+    kind: "assistant_final";
+    text: string;
+} | {
+    kind: "thinking_delta";
+    text: string;
+} | {
+    kind: "thinking_final";
+    text: string;
+} | {
+    kind: "tool_start";
+    callId: string;
+    name: string;
+    detail: string;
+    path?: string;
+    todos?: AgentTodoItem[];
+    questions?: ClarifyingQuestion[];
+    /** Set for MCP calls: which server / integration / tool ran. */
+    integration?: ToolIntegrationRef;
+} | {
+    kind: "tool_done";
+    callId: string;
+    name: string;
+    detail: string;
+    path?: string;
+    /** The tool failed / was rejected; `detail` carries the error. */
+    isError?: boolean;
+    diffPatch?: string;
+    todos?: AgentTodoItem[];
+    questions?: ClarifyingQuestion[];
+    /** Set for MCP calls: which server / integration / tool ran. */
+    integration?: ToolIntegrationRef;
+} | {
+    kind: "subagent_nested";
+    parentCallId: string;
+    callId: string;
+    name: string;
+    detail: string;
+    path?: string;
+    status: "started" | "completed";
+} | {
+    kind: "error";
+    message: string;
+}
+/**
+ * The agent's reply and tools are finished; the runner may still be doing
+ * post-run work (e.g. pushing the branch) before `done` arrives.
+ */
+ | {
+    kind: "turn_complete";
+    detail?: string;
+}
+/** Runner progress before/around the agent (e.g. "Starting sandbox…"); empty clears it. */
+ | {
+    kind: "status";
+    detail?: string;
+}
+/** Slash commands the CLI reported at startup (drives the composer menu). */
+ | {
+    kind: "cli_commands";
+    catalog: CliCommandCatalog;
+} | {
+    kind: "done";
+    result: string;
+    git?: RunGitInfo;
+    usage?: RunUsage;
+};
+export interface BuildArgsOptions {
+    prompt: string;
+    modelId: string;
+    sessionId?: string | null;
+    /** Cursor `--mode plan` / Claude `--permission-mode plan`. */
+    mode?: "agent" | "plan";
+    /** Working directory for Codex `--cd` (repo root in Blaxel). */
+    cwd?: string | null;
+    /** Streamable-HTTP MCP servers to attach for this invocation. */
+    mcpServers?: Record<string, {
+        type: "http";
+        url: string;
+        headers: Record<string, string>;
+    }>;
+}
+/**
+ * Abstraction over headless coding-agent CLIs.
+ * Implementations spawn the process and parse NDJSON into NormalizedAgentEvent.
+ */
+export interface WorkerBackend {
+    kind: AgentBackendKind;
+    /** False until the backend is fully wired and tested. */
+    available: boolean;
+    /** Executable name (`cursor`, `claude`, …). */
+    command: string;
+    buildArgs(opts: BuildArgsOptions): string[];
+    /** Extra env for this invocation (e.g. OpenCode inline MCP config). */
+    buildEnv?(opts: BuildArgsOptions): Record<string, string>;
+    /**
+     * Parse one JSON object from a stream-json line into zero or more
+     * normalized events. Stateful parsers may hold buffers on the instance;
+     * callers that need isolation should create a fresh backend per run.
+     */
+    parseLine(json: unknown, ctx?: ParseLineContext): NormalizedAgentEvent[];
+    /**
+     * Emit a terminal event the parser is holding back. OpenCode reports a
+     * `stop` on the step that *triggers* compaction too, so its `done` is
+     * deferred until the stream stays quiet (a new step cancels it) or the
+     * process exits. Call periodically and once on process close.
+     */
+    flush?(ctx?: ParseLineContext): NormalizedAgentEvent[];
+}
+export interface ParseLineContext {
+    /** Accumulated assistant text so far (mutated by the parser). */
+    assistantBuf: {
+        value: string;
+    };
+    /** Accumulated model thinking / reasoning for the current turn. */
+    thinkingBuf?: {
+        value: string;
+    };
+    /** Set true when a terminal result/done/error event is emitted. */
+    gotTerminalEvent: {
+        value: boolean;
+    };
+    /** Optional stderr buffer used for error messages. */
+    stderr?: string;
+    /**
+     * When true, only emit tool/session events (no assistant text / done / error).
+     * Used to re-parse Blaxel process stdout after streamLogs may have missed
+     * mid-run tool lines while still delivering the terminal result.
+     */
+    toolsOnly?: boolean;
+}

package/dist/shared/backends/types.js

@@ -0,0 +1,19 @@
+/** Claude Code, Codex, and OpenCode share the local-CLI + Blaxel-sandbox path. */
+export const CLI_SANDBOX_BACKENDS = ["claude-code", "codex", "opencode"];
+export function isCliSandboxBackend(kind) {
+    return kind === "claude-code" || kind === "codex" || kind === "opencode";
+}
+export function parseAgentBackendKind(raw) {
+    if (raw === "claude-code" || raw === "codex" || raw === "opencode")
+        return raw;
+    return "cursor";
+}
+export function backendShortLabel(kind) {
+    if (kind === "claude-code")
+        return "Claude";
+    if (kind === "codex")
+        return "Codex";
+    if (kind === "opencode")
+        return "OpenCode";
+    return "Cursor";
+}

package/dist/shared/backends/usage.d.ts

@@ -0,0 +1,8 @@
+import type { AgentBackendKind, RunUsage } from "./types.js";
+/** Claude Code `result` line: `usage` plus `total_cost_usd`. */
+export declare function claudeResultUsage(ev: Record<string, unknown>): RunUsage | undefined;
+/** Codex `turn.completed`: `usage` with input / cached / output tokens. */
+export declare function codexTurnUsage(ev: Record<string, unknown>): RunUsage | undefined;
+export declare function runUsageCostUsd(backend: AgentBackendKind, usage: RunUsage): number;
+export declare function addRunUsage(total: RunUsage, next: RunUsage, backend: AgentBackendKind): RunUsage;
+export declare const EMPTY_RUN_USAGE: RunUsage;

package/dist/shared/backends/usage.js

@@ -0,0 +1,71 @@
+function num(value) {
+    const n = typeof value === "number" ? value : Number(value);
+    return Number.isFinite(n) && n > 0 ? n : 0;
+}
+function record(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+/** Claude Code `result` line: `usage` plus `total_cost_usd`. */
+export function claudeResultUsage(ev) {
+    const usage = record(ev.usage);
+    const cost = num(ev.total_cost_usd);
+    if (!usage && !cost)
+        return undefined;
+    return {
+        inputTokens: num(usage?.input_tokens),
+        outputTokens: num(usage?.output_tokens),
+        cacheReadTokens: num(usage?.cache_read_input_tokens),
+        cacheWriteTokens: num(usage?.cache_creation_input_tokens),
+        ...(cost ? { costUsd: cost } : {}),
+    };
+}
+/** Codex `turn.completed`: `usage` with input / cached / output tokens. */
+export function codexTurnUsage(ev) {
+    const usage = record(ev.usage);
+    if (!usage)
+        return undefined;
+    const cached = num(usage.cached_input_tokens);
+    return {
+        // OpenAI counts cached tokens inside input_tokens.
+        inputTokens: Math.max(0, num(usage.input_tokens) - cached),
+        outputTokens: num(usage.output_tokens),
+        cacheReadTokens: cached,
+        cacheWriteTokens: 0,
+    };
+}
+/** USD per million tokens, used only when the CLI doesn't report cost. */
+const ESTIMATE_RATES = {
+    "claude-code": { input: 3, cached: 0.3, output: 15 },
+    codex: { input: 1.25, cached: 0.125, output: 10 },
+    // OpenCode reports cost directly; model-specific fallback rates would be wrong.
+    opencode: { input: 0, cached: 0, output: 0 },
+};
+export function runUsageCostUsd(backend, usage) {
+    if (usage.costUsd != null)
+        return usage.costUsd;
+    if (backend === "cursor")
+        return 0;
+    const rate = ESTIMATE_RATES[backend];
+    return ((usage.inputTokens * rate.input +
+        (usage.cacheReadTokens + usage.cacheWriteTokens) * rate.cached +
+        usage.outputTokens * rate.output) /
+        1_000_000);
+}
+export function addRunUsage(total, next, backend) {
+    return {
+        inputTokens: total.inputTokens + next.inputTokens,
+        outputTokens: total.outputTokens + next.outputTokens,
+        cacheReadTokens: total.cacheReadTokens + next.cacheReadTokens,
+        cacheWriteTokens: total.cacheWriteTokens + next.cacheWriteTokens,
+        costUsd: (total.costUsd ?? 0) + runUsageCostUsd(backend, next),
+    };
+}
+export const EMPTY_RUN_USAGE = {
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadTokens: 0,
+    cacheWriteTokens: 0,
+    costUsd: 0,
+};

package/dist/shared/billingPlans.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Workspace billing plans. `null` on a numeric limit means unlimited.
+ * Effective limits are PLAN_DEFAULTS, then BILLING_PLAN_OVERRIDES, then a
+ * per-organization override stored by an admin.
+ */
+export type PlanId = "free" | "team" | "business";
+export declare const PLAN_IDS: PlanId[];
+export declare const PLAN_RANK: Record<PlanId, number>;
+export declare const PLAN_LABELS: Record<PlanId, string>;
+/** Runner safety cap when a plan leaves concurrent issues unlimited. */
+export declare const ABSOLUTE_MAX_CONCURRENT_ISSUES = 64;
+export interface PlanLimits {
+    maxWorkspaces: number | null;
+    maxDrivers: number | null;
+    maxViewers: number | null;
+    maxConcurrentRooms: number | null;
+    maxConcurrentIssues: number | null;
+    maxQueuedIssues: number | null;
+    issuesPerDay: number | null;
+    swarmsPerWeek: number | null;
+    maxSwarmAgents: number | null;
+    swarmBudgetUsd: number | null;
+    maxIntegrations: number | null;
+    /**
+     * Included hosted-tool spend per calendar month, in USD.
+     * `0` blocks hosted calls. `null` means unlimited. Not per seat.
+     */
+    hostedToolsUsdPerMonth: number | null;
+    /** Included hosted minutes per calendar month. Team multiplies by driver seats. */
+    sandboxMinutesPerMonth: number | null;
+    sandboxMinutesPerSeat: boolean;
+    maxConcurrentSandboxes: number | null;
+    sandboxMaxRunMinutes: number | null;
+    sandboxMemoryMb: number;
+    allowOverage: boolean;
+    policy: boolean;
+    /** Days of audit-log history kept and shown. `null` keeps everything. */
+    auditRetentionDays: number | null;
+    auditExport: boolean;
+    sso: boolean;
+    customMcpAllowlist: boolean;
+    hostedSandbox: boolean;
+}
+export type PlanLimitKey = keyof PlanLimits;
+export declare const PLAN_DEFAULTS: Record<PlanId, PlanLimits>;
+export declare const LIMIT_LABELS: Record<PlanLimitKey, string>;
+export declare function isPlanId(value: unknown): value is PlanId;
+export declare function higherPlan(a: PlanId, b: PlanId): PlanId;
+export declare function parsePlanId(value: unknown, fallback?: PlanId): PlanId;
+/** Keep only known limit fields. `null` is preserved and means unlimited. */
+export declare function parseLimitsOverride(raw: unknown): Partial<PlanLimits> | null;
+export declare function mergePlanLimits(base: PlanLimits, ...overrides: Array<Partial<PlanLimits> | null | undefined>): PlanLimits;
+export declare function envPlanOverrides(): Partial<Record<PlanId, Partial<PlanLimits>>>;
+export declare function limitsForPlan(plan: PlanId, orgOverride?: Partial<PlanLimits> | null): PlanLimits;
+/** Oldest audit row a plan keeps/shows (ms epoch), or null for full history. */
+export declare function auditCutoffMs(limits: PlanLimits, now?: number): number | null;
+export declare function monthStartMs(now?: number): number;
+export declare function dayStartMs(now?: number): number;
+export declare function weekStartMs(now?: number): number;
+export declare function includedSandboxSeconds(limits: PlanLimits, driverSeats: number): number | null;

package/dist/shared/billingPlans.js

@@ -0,0 +1,262 @@
+/**
+ * Workspace billing plans. `null` on a numeric limit means unlimited.
+ * Effective limits are PLAN_DEFAULTS, then BILLING_PLAN_OVERRIDES, then a
+ * per-organization override stored by an admin.
+ */
+export const PLAN_IDS = ["free", "team", "business"];
+export const PLAN_RANK = {
+    free: 0,
+    team: 1,
+    business: 2,
+};
+export const PLAN_LABELS = {
+    free: "Free",
+    team: "Team",
+    business: "Business",
+};
+/** Runner safety cap when a plan leaves concurrent issues unlimited. */
+export const ABSOLUTE_MAX_CONCURRENT_ISSUES = 64;
+export const PLAN_DEFAULTS = {
+    free: {
+        maxWorkspaces: 2,
+        maxDrivers: 3,
+        maxViewers: 5,
+        maxConcurrentRooms: 3,
+        maxConcurrentIssues: 3,
+        maxQueuedIssues: 25,
+        issuesPerDay: 20,
+        swarmsPerWeek: 1,
+        maxSwarmAgents: 8,
+        swarmBudgetUsd: 25,
+        maxIntegrations: 10,
+        hostedToolsUsdPerMonth: 0,
+        sandboxMinutesPerMonth: 60,
+        sandboxMinutesPerSeat: false,
+        maxConcurrentSandboxes: 1,
+        sandboxMaxRunMinutes: 20,
+        sandboxMemoryMb: 2048,
+        allowOverage: false,
+        policy: false,
+        auditRetentionDays: 7,
+        auditExport: false,
+        sso: false,
+        customMcpAllowlist: false,
+        hostedSandbox: true,
+    },
+    team: {
+        maxWorkspaces: 10,
+        maxDrivers: null,
+        maxViewers: null,
+        maxConcurrentRooms: 25,
+        maxConcurrentIssues: 15,
+        maxQueuedIssues: 200,
+        issuesPerDay: null,
+        swarmsPerWeek: 20,
+        maxSwarmAgents: 20,
+        swarmBudgetUsd: 100,
+        maxIntegrations: null,
+        hostedToolsUsdPerMonth: 0,
+        sandboxMinutesPerMonth: 600,
+        sandboxMinutesPerSeat: true,
+        maxConcurrentSandboxes: 10,
+        sandboxMaxRunMinutes: 120,
+        sandboxMemoryMb: 4096,
+        allowOverage: true,
+        policy: true,
+        auditRetentionDays: 90,
+        auditExport: false,
+        sso: false,
+        customMcpAllowlist: false,
+        hostedSandbox: true,
+    },
+    business: {
+        maxWorkspaces: null,
+        maxDrivers: null,
+        maxViewers: null,
+        maxConcurrentRooms: null,
+        maxConcurrentIssues: null,
+        maxQueuedIssues: null,
+        issuesPerDay: null,
+        swarmsPerWeek: null,
+        maxSwarmAgents: null,
+        swarmBudgetUsd: null,
+        maxIntegrations: null,
+        hostedToolsUsdPerMonth: 0,
+        sandboxMinutesPerMonth: null,
+        sandboxMinutesPerSeat: false,
+        maxConcurrentSandboxes: null,
+        sandboxMaxRunMinutes: 240,
+        sandboxMemoryMb: 8192,
+        allowOverage: true,
+        policy: true,
+        auditRetentionDays: null,
+        auditExport: true,
+        sso: true,
+        customMcpAllowlist: true,
+        hostedSandbox: true,
+    },
+};
+const NUMERIC_KEYS = [
+    "maxWorkspaces",
+    "maxDrivers",
+    "maxViewers",
+    "maxConcurrentRooms",
+    "maxConcurrentIssues",
+    "maxQueuedIssues",
+    "issuesPerDay",
+    "swarmsPerWeek",
+    "maxSwarmAgents",
+    "swarmBudgetUsd",
+    "maxIntegrations",
+    "hostedToolsUsdPerMonth",
+    "sandboxMinutesPerMonth",
+    "maxConcurrentSandboxes",
+    "sandboxMaxRunMinutes",
+    "sandboxMemoryMb",
+    "auditRetentionDays",
+];
+const BOOLEAN_KEYS = [
+    "sandboxMinutesPerSeat",
+    "allowOverage",
+    "policy",
+    "auditExport",
+    "sso",
+    "customMcpAllowlist",
+    "hostedSandbox",
+];
+export const LIMIT_LABELS = {
+    maxWorkspaces: "workspaces",
+    maxDrivers: "drivers",
+    maxViewers: "viewers",
+    maxConcurrentRooms: "concurrent rooms",
+    maxConcurrentIssues: "concurrent issues",
+    maxQueuedIssues: "queued issues",
+    issuesPerDay: "issue runs per day",
+    swarmsPerWeek: "swarms per week",
+    maxSwarmAgents: "swarm agents",
+    swarmBudgetUsd: "swarm budget",
+    maxIntegrations: "integrations",
+    hostedToolsUsdPerMonth: "hosted tools",
+    sandboxMinutesPerMonth: "hosted sandbox minutes",
+    sandboxMinutesPerSeat: "sandbox minutes per seat",
+    maxConcurrentSandboxes: "concurrent sandboxes",
+    sandboxMaxRunMinutes: "sandbox run length",
+    sandboxMemoryMb: "sandbox memory",
+    allowOverage: "sandbox overage",
+    policy: "integration policy",
+    auditRetentionDays: "audit log history",
+    auditExport: "audit export",
+    sso: "SSO",
+    customMcpAllowlist: "custom MCP allowlist",
+    hostedSandbox: "hosted sandboxes",
+};
+export function isPlanId(value) {
+    return value === "free" || value === "team" || value === "business";
+}
+export function higherPlan(a, b) {
+    return PLAN_RANK[a] >= PLAN_RANK[b] ? a : b;
+}
+export function parsePlanId(value, fallback = "free") {
+    return isPlanId(value) ? value : fallback;
+}
+function asLimitNumber(value) {
+    if (value === null)
+        return null;
+    if (typeof value === "number" && Number.isFinite(value) && value >= 0) {
+        return value;
+    }
+    if (typeof value === "string" && value.trim()) {
+        const n = Number(value);
+        if (Number.isFinite(n) && n >= 0)
+            return n;
+    }
+    return undefined;
+}
+/** Keep only known limit fields. `null` is preserved and means unlimited. */
+export function parseLimitsOverride(raw) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw))
+        return null;
+    const src = raw;
+    const out = {};
+    let any = false;
+    for (const key of NUMERIC_KEYS) {
+        if (!(key in src))
+            continue;
+        const n = asLimitNumber(src[key]);
+        if (n === undefined)
+            continue;
+        out[key] = n;
+        any = true;
+    }
+    for (const key of BOOLEAN_KEYS) {
+        if (typeof src[key] === "boolean") {
+            out[key] = src[key];
+            any = true;
+        }
+    }
+    return any ? out : null;
+}
+export function mergePlanLimits(base, ...overrides) {
+    const out = { ...base };
+    for (const over of overrides) {
+        if (!over)
+            continue;
+        for (const key of NUMERIC_KEYS) {
+            if (over[key] !== undefined) {
+                out[key] = over[key];
+            }
+        }
+        for (const key of BOOLEAN_KEYS) {
+            if (over[key] !== undefined)
+                out[key] = over[key];
+        }
+    }
+    if (!Number.isFinite(out.sandboxMemoryMb) || out.sandboxMemoryMb < 512) {
+        out.sandboxMemoryMb = base.sandboxMemoryMb;
+    }
+    return out;
+}
+export function envPlanOverrides() {
+    const raw = process.env.BILLING_PLAN_OVERRIDES?.trim();
+    if (!raw)
+        return {};
+    try {
+        const parsed = JSON.parse(raw);
+        const out = {};
+        for (const id of PLAN_IDS) {
+            const patch = parseLimitsOverride(parsed[id]);
+            if (patch)
+                out[id] = patch;
+        }
+        return out;
+    }
+    catch {
+        return {};
+    }
+}
+export function limitsForPlan(plan, orgOverride) {
+    return mergePlanLimits(PLAN_DEFAULTS[plan], envPlanOverrides()[plan], orgOverride);
+}
+/** Oldest audit row a plan keeps/shows (ms epoch), or null for full history. */
+export function auditCutoffMs(limits, now = Date.now()) {
+    if (limits.auditRetentionDays == null)
+        return null;
+    return now - limits.auditRetentionDays * 24 * 60 * 60 * 1000;
+}
+export function monthStartMs(now = Date.now()) {
+    const d = new Date(now);
+    return Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), 1);
+}
+export function dayStartMs(now = Date.now()) {
+    const d = new Date(now);
+    return Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate());
+}
+export function weekStartMs(now = Date.now()) {
+    return now - 7 * 24 * 60 * 60 * 1000;
+}
+export function includedSandboxSeconds(limits, driverSeats) {
+    if (limits.sandboxMinutesPerMonth == null)
+        return null;
+    const seats = limits.sandboxMinutesPerSeat ? Math.max(1, driverSeats) : 1;
+    return Math.round(limits.sandboxMinutesPerMonth * seats * 60);
+}