@geteigen/cli 0.0.0-stage → 3.0.0

package/dist/shared/agentMentions.js

@@ -0,0 +1,110 @@
+/**
+ * "@Agent name" / "@Person" mentions in the Space composer.
+ *
+ * Labels may contain spaces ("Research Agent"), so matching is done against
+ * the known agent labels (longest first) rather than a generic @word regex.
+ */
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function byLongestLabel(agents) {
+    return agents
+        .filter((a) => a.label.trim())
+        .sort((a, b) => b.label.length - a.label.length);
+}
+function mentionPattern(label) {
+    // @label not followed by another word character (so "@Agent" ≠ "@Agents").
+    return new RegExp(`(^|[^\\w@])@${escapeRegExp(label.trim())}(?![\\w-])`, "gi");
+}
+export function parseAgentMentions(input, agents) {
+    const found = [];
+    let text = input;
+    for (const agent of byLongestLabel(agents)) {
+        const re = mentionPattern(agent.label);
+        let first = -1;
+        text = text.replace(re, (_match, lead, offset) => {
+            if (first < 0)
+                first = offset;
+            // Placeholder keeps offsets stable for shorter labels matched later.
+            return `${lead}\u0000${agent.label.trim()}\u0001`;
+        });
+        if (first >= 0)
+            found.push({ id: agent.id, index: first });
+    }
+    // Leading run of mentions ("@A @B, do X") addresses the agents — drop it.
+    text = text.replace(/^(\s*\u0000[^\u0001]*\u0001[\s,:;]*)+/, "");
+    // Inline mentions read naturally as plain names.
+    text = text.replace(/\u0000([^\u0001]*)\u0001/g, "$1").trim();
+    return {
+        agentIds: found.sort((a, b) => a.index - b.index).map((f) => f.id),
+        text,
+    };
+}
+/**
+ * Active "@query" at the end of the draft (caret assumed at the end), or
+ * null when the user isn't mentioning anyone right now.
+ */
+export function activeMentionQuery(draft) {
+    const match = /(?:^|\s)@([^@\n]{0,40})$/.exec(draft);
+    return match ? match[1] : null;
+}
+/** Agents whose label starts with (or contains) the query. */
+export function matchMentionAgents(agents, query) {
+    const q = query.toLowerCase();
+    const starts = agents.filter((a) => a.label.toLowerCase().startsWith(q));
+    if (q.includes(" "))
+        return starts;
+    const contains = agents.filter((a) => !starts.includes(a) && a.label.toLowerCase().includes(q));
+    return [...starts, ...contains];
+}
+/** Replace the trailing "@query" with a completed "@Label ". */
+export function completeMention(draft, label) {
+    return draft.replace(/@([^@\n]{0,40})$/, `@${label} `);
+}
+/** People mentioned in a draft (kept in the text, unlike agent mentions). */
+export function findMentions(text, targets) {
+    const found = [];
+    let scan = text;
+    for (const target of byLongestLabel(targets)) {
+        const re = mentionPattern(target.label);
+        let first = -1;
+        scan = scan.replace(re, (match, lead, offset) => {
+            if (first < 0)
+                first = offset;
+            // Blank out so a shorter label can't match inside a longer one.
+            return lead + " ".repeat(match.length - lead.length);
+        });
+        if (first >= 0)
+            found.push({ target, index: first });
+    }
+    return found.sort((a, b) => a.index - b.index).map((f) => f.target);
+}
+/** Split text into plain runs and "@Label" mentions for rendering chips. */
+export function segmentMentions(text, targets) {
+    const hits = [];
+    for (const target of byLongestLabel(targets)) {
+        const re = mentionPattern(target.label);
+        let m;
+        while ((m = re.exec(text))) {
+            const start = m.index + m[1].length;
+            const end = m.index + m[0].length;
+            if (hits.some((h) => start < h.end && end > h.start))
+                continue;
+            hits.push({ start, end, target });
+        }
+    }
+    if (!hits.length)
+        return [{ kind: "text", text }];
+    hits.sort((a, b) => a.start - b.start);
+    const out = [];
+    let at = 0;
+    for (const h of hits) {
+        if (h.start > at)
+            out.push({ kind: "text", text: text.slice(at, h.start) });
+        out.push({ kind: "mention", text: text.slice(h.start, h.end), target: h.target });
+        at = h.end;
+    }
+    if (at < text.length)
+        out.push({ kind: "text", text: text.slice(at) });
+    return out;
+}

package/dist/shared/agentRepos.d.ts

@@ -0,0 +1,28 @@
+export type AgentRepoSource = "github" | "cursor";
+/** One repository the add-agent picker can show (GitHub account and/or Cursor). */
+export interface AgentRepoChoice {
+    url: string;
+    fullName: string;
+    /** Known from GitHub. Cursor-only rows leave this null. */
+    private: boolean | null;
+    defaultBranch: string;
+    sources: AgentRepoSource[];
+}
+export declare function githubRepoFullName(url: string): string | null;
+/**
+ * Merge the workspace GitHub list (includes private repos the token can see)
+ * with Cursor Cloud's connected repositories. Same URL appears once.
+ */
+export declare function mergeAgentRepos(input: {
+    github?: Array<{
+        url: string;
+        fullName: string;
+        private: boolean;
+        defaultBranch?: string;
+    }>;
+    cursor?: Array<{
+        url: string;
+    }>;
+}): AgentRepoChoice[];
+export declare function filterAgentRepos(repos: AgentRepoChoice[], query: string): AgentRepoChoice[];
+export declare function addAgentHref(roomId: string): string;

package/dist/shared/agentRepos.js

@@ -0,0 +1,60 @@
+import { parseGithubHttpsRepo } from "./issues";
+export function githubRepoFullName(url) {
+    const parsed = parseGithubHttpsRepo(url);
+    if (!parsed)
+        return null;
+    const m = parsed.match(/^https:\/\/github\.com\/([^/]+)\/([^/]+)$/i);
+    return m ? `${m[1]}/${m[2]}` : null;
+}
+function repoKey(url) {
+    return (parseGithubHttpsRepo(url) || url.trim()).toLowerCase();
+}
+/**
+ * Merge the workspace GitHub list (includes private repos the token can see)
+ * with Cursor Cloud's connected repositories. Same URL appears once.
+ */
+export function mergeAgentRepos(input) {
+    const byKey = new Map();
+    for (const row of input.github || []) {
+        const url = parseGithubHttpsRepo(row.url) || row.url.trim();
+        if (!url)
+            continue;
+        byKey.set(repoKey(url), {
+            url,
+            fullName: row.fullName || githubRepoFullName(url) || url,
+            private: Boolean(row.private),
+            defaultBranch: row.defaultBranch || "main",
+            sources: ["github"],
+        });
+    }
+    for (const row of input.cursor || []) {
+        const url = parseGithubHttpsRepo(row.url) || row.url.trim();
+        if (!url)
+            continue;
+        const key = repoKey(url);
+        const existing = byKey.get(key);
+        if (existing) {
+            if (!existing.sources.includes("cursor"))
+                existing.sources.push("cursor");
+            continue;
+        }
+        byKey.set(key, {
+            url,
+            fullName: githubRepoFullName(url) || url,
+            private: null,
+            defaultBranch: "main",
+            sources: ["cursor"],
+        });
+    }
+    return [...byKey.values()].sort((a, b) => a.fullName.localeCompare(b.fullName, undefined, { sensitivity: "base" }));
+}
+export function filterAgentRepos(repos, query) {
+    const q = query.trim().toLowerCase();
+    if (!q)
+        return repos;
+    return repos.filter((repo) => repo.fullName.toLowerCase().includes(q) ||
+        repo.url.toLowerCase().includes(q));
+}
+export function addAgentHref(roomId) {
+    return `/room/${encodeURIComponent(roomId)}/agents/new`;
+}

package/dist/shared/agentRunStatus.d.ts

@@ -0,0 +1,12 @@
+import type { AgentRunStatus, AgentStatus } from "./events.js";
+/** Map persisted agent status onto the run states the chat input cares about. */
+export declare function toAgentRunStatus(status?: AgentStatus | AgentRunStatus | string | null): AgentRunStatus;
+/**
+ * Busy / error for the agent currently in view.
+ * Live socket status wins; otherwise the agent snapshot.
+ * Never falls back to another agent's room-level run status.
+ */
+export declare function resolveAgentRunStatus(agent: {
+    id?: string;
+    status?: AgentStatus | string;
+} | null | undefined, statusByAgent?: Record<string, AgentRunStatus>): AgentRunStatus;

package/dist/shared/agentRunStatus.js

@@ -0,0 +1,17 @@
+/** Map persisted agent status onto the run states the chat input cares about. */
+export function toAgentRunStatus(status) {
+    if (status === "running" || status === "error")
+        return status;
+    return "idle";
+}
+/**
+ * Busy / error for the agent currently in view.
+ * Live socket status wins; otherwise the agent snapshot.
+ * Never falls back to another agent's room-level run status.
+ */
+export function resolveAgentRunStatus(agent, statusByAgent = {}) {
+    const live = agent?.id ? statusByAgent[agent.id] : undefined;
+    if (live)
+        return toAgentRunStatus(live);
+    return toAgentRunStatus(agent?.status);
+}

package/dist/shared/agentUsage.d.ts

@@ -0,0 +1,24 @@
+import type { AgentUsageInfo } from "./events.js";
+import type { AgentBackendKind, RunUsage } from "./backends/types.js";
+export type SdkUsageLike = {
+    usage?: {
+        inputTokens?: number;
+        outputTokens?: number;
+        cacheReadTokens?: number;
+        cacheWriteTokens?: number;
+        totalTokens?: number;
+        reasoningTokens?: number;
+    } | null;
+    cost?: {
+        rawCostCents?: number;
+        chargedCents?: number;
+    } | null;
+} | null;
+export declare function agentUsageFromSdk(raw: SdkUsageLike): AgentUsageInfo | null;
+export declare function parseAgentUsageJson(raw: unknown): AgentUsageInfo | undefined;
+/** Add one CLI turn to the persisted usage total. */
+export declare function addRunUsageToAgent(previous: AgentUsageInfo | undefined, run: RunUsage, backend: AgentBackendKind, modelId: string): AgentUsageInfo;
+export declare function formatTokenCount(n: number): string;
+export declare function formatUsageCost(usage: AgentUsageInfo): string | null;
+export declare function formatAgentUsage(usage: AgentUsageInfo): string;
+export declare function formatAgentUsageDetail(usage: AgentUsageInfo): string;

package/dist/shared/agentUsage.js

@@ -0,0 +1,139 @@
+import { runUsageCostUsd } from "./backends/usage.js";
+import { contextWindowForModel } from "./contextWindows.js";
+function num(value) {
+    const n = typeof value === "number" ? value : Number(value);
+    return Number.isFinite(n) ? n : 0;
+}
+export function agentUsageFromSdk(raw) {
+    if (!raw?.usage)
+        return null;
+    const usage = raw.usage;
+    const info = {
+        inputTokens: num(usage.inputTokens),
+        outputTokens: num(usage.outputTokens),
+        cacheReadTokens: num(usage.cacheReadTokens),
+        cacheWriteTokens: num(usage.cacheWriteTokens),
+        totalTokens: num(usage.totalTokens),
+        contextTokens: num(usage.inputTokens) +
+            num(usage.cacheReadTokens) +
+            num(usage.cacheWriteTokens),
+        updatedAt: Date.now(),
+    };
+    if (usage.reasoningTokens != null) {
+        info.reasoningTokens = num(usage.reasoningTokens);
+    }
+    if (raw.cost) {
+        info.rawCostCents = num(raw.cost.rawCostCents);
+        info.chargedCents = num(raw.cost.chargedCents);
+    }
+    return info;
+}
+export function parseAgentUsageJson(raw) {
+    if (!raw)
+        return undefined;
+    let parsed = raw;
+    if (typeof raw === "string") {
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    if (!parsed || typeof parsed !== "object")
+        return undefined;
+    const row = parsed;
+    const totalTokens = num(row.totalTokens);
+    const inputTokens = num(row.inputTokens);
+    const outputTokens = num(row.outputTokens);
+    if (totalTokens <= 0 && inputTokens <= 0 && outputTokens <= 0) {
+        return undefined;
+    }
+    const info = {
+        inputTokens,
+        outputTokens,
+        cacheReadTokens: num(row.cacheReadTokens),
+        cacheWriteTokens: num(row.cacheWriteTokens),
+        totalTokens: totalTokens || inputTokens + outputTokens,
+        updatedAt: num(row.updatedAt) || Date.now(),
+    };
+    if (row.reasoningTokens != null)
+        info.reasoningTokens = num(row.reasoningTokens);
+    if (row.rawCostCents != null)
+        info.rawCostCents = num(row.rawCostCents);
+    if (row.chargedCents != null)
+        info.chargedCents = num(row.chargedCents);
+    if (row.contextTokens != null)
+        info.contextTokens = num(row.contextTokens);
+    if (row.contextWindowTokens != null) {
+        info.contextWindowTokens = num(row.contextWindowTokens);
+    }
+    return info;
+}
+/** Add one CLI turn to the persisted usage total. */
+export function addRunUsageToAgent(previous, run, backend, modelId) {
+    const input = (previous?.inputTokens ?? 0) + run.inputTokens;
+    const output = (previous?.outputTokens ?? 0) + run.outputTokens;
+    const cacheRead = (previous?.cacheReadTokens ?? 0) + run.cacheReadTokens;
+    const cacheWrite = (previous?.cacheWriteTokens ?? 0) + run.cacheWriteTokens;
+    const costCents = Math.round(runUsageCostUsd(backend, run) * 100);
+    const info = {
+        inputTokens: input,
+        outputTokens: output,
+        cacheReadTokens: cacheRead,
+        cacheWriteTokens: cacheWrite,
+        totalTokens: (previous?.totalTokens ?? 0) + run.inputTokens + run.outputTokens,
+        contextTokens: run.inputTokens + run.cacheReadTokens + run.cacheWriteTokens,
+        updatedAt: Date.now(),
+    };
+    const window = contextWindowForModel(backend, modelId);
+    if (window)
+        info.contextWindowTokens = window;
+    else if (previous?.contextWindowTokens) {
+        info.contextWindowTokens = previous.contextWindowTokens;
+    }
+    const rawCostCents = (previous?.rawCostCents ?? 0) + costCents;
+    const chargedCents = (previous?.chargedCents ?? 0) + costCents;
+    if (rawCostCents)
+        info.rawCostCents = rawCostCents;
+    if (chargedCents)
+        info.chargedCents = chargedCents;
+    return info;
+}
+export function formatTokenCount(n) {
+    const abs = Math.max(0, Math.round(n));
+    if (abs < 1000)
+        return `${abs}`;
+    if (abs < 10_000)
+        return `${(abs / 1000).toFixed(1).replace(/\.0$/, "")}k`;
+    if (abs < 1_000_000)
+        return `${Math.round(abs / 1000)}k`;
+    return `${(abs / 1_000_000).toFixed(1).replace(/\.0$/, "")}M`;
+}
+export function formatUsageCost(usage) {
+    const cents = Math.max(usage.chargedCents ?? 0, usage.rawCostCents ?? 0);
+    if (!cents)
+        return null;
+    const usd = cents / 100;
+    if (usd < 0.01)
+        return "<$0.01";
+    return `$${usd.toFixed(usd < 10 ? 2 : 2)}`;
+}
+export function formatAgentUsage(usage) {
+    const tokens = `${formatTokenCount(usage.totalTokens)} tok`;
+    const cost = formatUsageCost(usage);
+    return cost ? `${tokens} · ${cost}` : tokens;
+}
+export function formatAgentUsageDetail(usage) {
+    const parts = [
+        `in ${formatTokenCount(usage.inputTokens)}`,
+        `out ${formatTokenCount(usage.outputTokens)}`,
+    ];
+    if (usage.cacheReadTokens) {
+        parts.push(`cache ${formatTokenCount(usage.cacheReadTokens)}`);
+    }
+    const cost = formatUsageCost(usage);
+    if (cost)
+        parts.push(cost);
+    return parts.join(" · ");
+}

package/dist/shared/approvals.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Approval gates for high-blast-radius agent actions.
+ * Separate from file locks — these need a human sign-off in the room.
+ */
+export type ApprovalMode = "off" | "dangerous" | "all";
+export type AgentMode = "agent" | "plan";
+export type ApprovalStatus = "pending" | "approved" | "denied" | "expired";
+export interface ApprovalRequestInfo {
+    id: string;
+    roomId: string;
+    agentId: string;
+    callId: string;
+    toolName: string;
+    detail: string;
+    path?: string;
+    status: ApprovalStatus;
+    createdAt: number;
+    decidedAt?: number;
+    decidedByUserId?: string;
+    decidedByName?: string;
+}
+export declare function parseApprovalMode(raw: unknown, fallback?: ApprovalMode): ApprovalMode;
+export declare function parseAgentMode(raw: unknown, fallback?: AgentMode): AgentMode;
+export declare function approvalModeLabel(mode: ApprovalMode): string;
+export declare function approvalModeDescription(mode: ApprovalMode): string;
+export declare function agentModeLabel(mode: AgentMode): string;
+export declare function agentModeDescription(mode: AgentMode): string;
+export declare function isShellTool(name: string): boolean;
+export declare function isDeleteTool(name: string): boolean;
+export declare function isSensitivePath(path: string | undefined): boolean;
+export declare function isDangerousShellCommand(detail: string | undefined): boolean;
+/**
+ * Whether this tool call should pause for human approval given the room mode.
+ * `isEdit` is injected so we don't duplicate EDIT_TOOL_RE across modules.
+ */
+export declare function requiresApproval(opts: {
+    mode: ApprovalMode;
+    toolName: string;
+    detail?: string;
+    path?: string;
+    isEditTool: (name: string) => boolean;
+}): boolean;
+/** Stable key so an approved action can be resumed without re-prompting. */
+export declare function approvalActionKey(toolName: string, detail: string, path?: string): string;

package/dist/shared/approvals.js

@@ -0,0 +1,97 @@
+/**
+ * Approval gates for high-blast-radius agent actions.
+ * Separate from file locks — these need a human sign-off in the room.
+ */
+export function parseApprovalMode(raw, fallback = "off") {
+    const v = String(raw ?? "").trim().toLowerCase();
+    if (v === "off" || v === "dangerous" || v === "all")
+        return v;
+    return fallback;
+}
+export function parseAgentMode(raw, fallback = "agent") {
+    const v = String(raw ?? "").trim().toLowerCase();
+    if (v === "plan" || v === "agent")
+        return v;
+    if (v === "true" || v === "1")
+        return "plan";
+    if (v === "false" || v === "0")
+        return "agent";
+    return fallback;
+}
+export function approvalModeLabel(mode) {
+    switch (mode) {
+        case "off":
+            return "No approvals";
+        case "dangerous":
+            return "Dangerous actions";
+        case "all":
+            return "All edits & shell";
+    }
+}
+export function approvalModeDescription(mode) {
+    switch (mode) {
+        case "off":
+            return "Agents run tools without a second human sign-off.";
+        case "dangerous":
+            return "Migrations, deletes, pushes to main, CI/secrets changes pause for approval.";
+        case "all":
+            return "Every edit and shell command pauses for room approval.";
+    }
+}
+export function agentModeLabel(mode) {
+    return mode === "plan" ? "Plan" : "Agent";
+}
+export function agentModeDescription(mode) {
+    return mode === "plan"
+        ? "Read-only planning — the agent explores and proposes without editing."
+        : "Full agent mode — the agent can edit files and run commands.";
+}
+/** Shell / terminal tool names across agent backends. */
+const SHELL_TOOL_RE = /^(shell|bash|run_terminal_cmd|runterminalcmd|terminal|execute|command|Bash)$/i;
+/** Explicit delete tools. */
+const DELETE_TOOL_RE = /^(delete|deletefile|delete_file|Remove|remove)$/i;
+/** High-blast-radius shell command patterns. */
+const DANGEROUS_SHELL_RE = /\b(rm\s+(-[a-zA-Z]*r[a-zA-Z]*f|-[a-zA-Z]*f[a-zA-Z]*r)|rm\s+-rf|rmdir\s+-r|sudo\s+|drop\s+(table|database|schema)|truncate\s+table|migrate|prisma\s+migrate|knex\s+migrate|django(-admin)?\s+migrate|rails\s+db:migrate|flyway|liquibase|git\s+push\s+.*\b(--force|-f)\b|git\s+push\s+.*\b(main|master)\b|git\s+branch\s+(-D|-d)\b|git\s+reset\s+--hard|git\s+clean\s+-f|kubectl\s+delete|terraform\s+destroy|helm\s+uninstall|dd\s+if=|mkfs\.|chmod\s+-R\s+777|curl\s+.*\|\s*(ba)?sh)\b/i;
+/** Paths that need a second pair of eyes before edit/delete. */
+const SENSITIVE_PATH_RE = /(^|\/)(\.env($|\.)|\.env\.[^/]+|.*secrets?.*|.*credentials?.*|\.pem$|\.key$|\.p12$|\.pfx$|id_rsa|id_ed25519|\.npmrc|\.netrc|aws\/credentials|\.kube\/config|\.github\/workflows\/|Jenkinsfile|cloudbuild\.ya?ml|\.gitlab-ci\.ya?ml|azure-pipelines\.ya?ml|bitbucket-pipelines\.ya?ml|buildkite\.ya?ml|circleci\/config\.ya?ml|travis\.ya?ml|Dockerfile|docker-compose.*\.ya?ml|terraform\/|.*\.tf$)/i;
+export function isShellTool(name) {
+    const n = name.replace(/ToolCall$/i, "");
+    return SHELL_TOOL_RE.test(n);
+}
+export function isDeleteTool(name) {
+    const n = name.replace(/ToolCall$/i, "");
+    return DELETE_TOOL_RE.test(n) || /^delete/i.test(n);
+}
+export function isSensitivePath(path) {
+    if (!path?.trim())
+        return false;
+    return SENSITIVE_PATH_RE.test(path.replace(/\\/g, "/"));
+}
+export function isDangerousShellCommand(detail) {
+    if (!detail?.trim())
+        return false;
+    return DANGEROUS_SHELL_RE.test(detail);
+}
+/**
+ * Whether this tool call should pause for human approval given the room mode.
+ * `isEdit` is injected so we don't duplicate EDIT_TOOL_RE across modules.
+ */
+export function requiresApproval(opts) {
+    const { mode, toolName, detail, path, isEditTool } = opts;
+    if (mode === "off")
+        return false;
+    const shell = isShellTool(toolName);
+    const del = isDeleteTool(toolName);
+    const edit = isEditTool(toolName);
+    const sensitive = isSensitivePath(path) || isSensitivePath(detail);
+    const dangerousShell = shell && isDangerousShellCommand(detail);
+    if (mode === "all") {
+        return shell || edit || del;
+    }
+    // dangerous
+    return dangerousShell || del || (edit && sensitive) || (shell && sensitive);
+}
+/** Stable key so an approved action can be resumed without re-prompting. */
+export function approvalActionKey(toolName, detail, path) {
+    return `${toolName.trim().toLowerCase()}::${(path || "").trim()}::${detail.trim()}`.slice(0, 500);
+}