@geteigen/cli 0.0.0-stage → 3.1.0

package/dist/listModels.js

@@ -0,0 +1,62 @@
+import { execFile } from "child_process";
+import { promisify } from "util";
+const execFileAsync = promisify(execFile);
+const ANSI_RE = /\x1b\[[0-9;]*[a-zA-Z]/g;
+const MODEL_LINE_RE = /^([a-zA-Z0-9][a-zA-Z0-9._-]*)\s+[-–—]\s+(.+)$/;
+function stripAnsi(text) {
+    return text.replace(ANSI_RE, "").replace(/\r/g, "");
+}
+function parseModels(stdout) {
+    const models = [];
+    const seen = new Set();
+    for (const raw of stripAnsi(stdout).split("\n")) {
+        const line = raw.trim();
+        if (!line || /^available models$/i.test(line))
+            continue;
+        const m = line.match(MODEL_LINE_RE);
+        if (!m)
+            continue;
+        const id = m[1];
+        if (seen.has(id))
+            continue;
+        seen.add(id);
+        models.push({ id, displayName: m[2].trim() });
+    }
+    return models;
+}
+async function runListModels() {
+    try {
+        const { stdout } = await execFileAsync("cursor", ["agent", "--list-models"], {
+            timeout: 60_000,
+            encoding: "utf8",
+            maxBuffer: 16 * 1024 * 1024,
+            env: {
+                ...process.env,
+                NO_COLOR: "1",
+                FORCE_COLOR: "0",
+                TERM: "dumb",
+            },
+        });
+        return stdout || "";
+    }
+    catch (err) {
+        const e = err;
+        if (e.stdout && String(e.stdout).trim())
+            return String(e.stdout);
+        if (e.code === "ENOENT") {
+            throw new Error("cursor CLI not found. Install Cursor and ensure `cursor` is on PATH.");
+        }
+        throw new Error(e.stderr?.trim() ||
+            e.message ||
+            "Failed to run `cursor agent --list-models`");
+    }
+}
+/** Models available to the logged-in Cursor CLI on this machine. */
+export async function listLocalModels() {
+    const stdout = await runListModels();
+    const models = parseModels(stdout);
+    if (models.length === 0) {
+        return [{ id: "auto", displayName: "Auto" }];
+    }
+    return models;
+}

package/dist/listSessions.d.ts

@@ -0,0 +1,9 @@
+export interface CursorChatSession {
+    id: string;
+    createdAt: number;
+    updatedAt: number;
+    hasConversation: boolean;
+}
+/** MD5 of resolved repo path — matches Cursor's ~/.cursor/chats layout. */
+export declare function workspaceChatHash(repoPath: string): string;
+export declare function listChatSessions(repoPath: string): CursorChatSession[];

package/dist/listSessions.js

@@ -0,0 +1,37 @@
+import { createHash } from "crypto";
+import { existsSync, readdirSync, readFileSync } from "fs";
+import { homedir } from "os";
+import { join, resolve } from "path";
+/** MD5 of resolved repo path — matches Cursor's ~/.cursor/chats layout. */
+export function workspaceChatHash(repoPath) {
+    return createHash("md5").update(resolve(repoPath)).digest("hex");
+}
+export function listChatSessions(repoPath) {
+    const absRepo = resolve(repoPath);
+    const root = join(homedir(), ".cursor", "chats", workspaceChatHash(absRepo));
+    if (!existsSync(root))
+        return [];
+    const sessions = [];
+    for (const id of readdirSync(root, { withFileTypes: true })) {
+        if (!id.isDirectory())
+            continue;
+        const metaPath = join(root, id.name, "meta.json");
+        if (!existsSync(metaPath))
+            continue;
+        try {
+            const meta = JSON.parse(readFileSync(metaPath, "utf8"));
+            if (meta.cwd && resolve(meta.cwd) !== absRepo)
+                continue;
+            sessions.push({
+                id: id.name,
+                createdAt: meta.createdAtMs ?? 0,
+                updatedAt: meta.updatedAtMs ?? meta.createdAtMs ?? 0,
+                hasConversation: Boolean(meta.hasConversation),
+            });
+        }
+        catch {
+            // skip malformed entries
+        }
+    }
+    return sessions.sort((a, b) => b.updatedAt - a.updatedAt);
+}

package/dist/pickFolder.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Open a native OS folder picker and return an absolute path.
+ * Returns null if the user cancels.
+ */
+export declare function pickFolder(): Promise<string | null>;

package/dist/pickFolder.js

@@ -0,0 +1,65 @@
+import { execFile } from "child_process";
+import { promisify } from "util";
+import { platform } from "os";
+const execFileAsync = promisify(execFile);
+/**
+ * Open a native OS folder picker and return an absolute path.
+ * Returns null if the user cancels.
+ */
+export async function pickFolder() {
+    const os = platform();
+    try {
+        if (os === "darwin") {
+            const { stdout } = await execFileAsync("osascript", [
+                "-e",
+                'POSIX path of (choose folder with prompt "Select a repository folder")',
+            ]);
+            const path = stdout.trim().replace(/\/$/, "");
+            return path || null;
+        }
+        if (os === "win32") {
+            const script = [
+                "Add-Type -AssemblyName System.Windows.Forms",
+                "$d = New-Object System.Windows.Forms.FolderBrowserDialog",
+                '$d.Description = "Select a repository folder"',
+                "$d.ShowNewFolderButton = $true",
+                "if ($d.ShowDialog() -eq [System.Windows.Forms.DialogResult]::OK) { Write-Output $d.SelectedPath }",
+            ].join("; ");
+            const { stdout } = await execFileAsync("powershell", [
+                "-NoProfile",
+                "-Command",
+                script,
+            ]);
+            const path = stdout.trim();
+            return path || null;
+        }
+        // Linux: prefer zenity, then kdialog
+        try {
+            const { stdout } = await execFileAsync("zenity", [
+                "--file-selection",
+                "--directory",
+                "--title=Select a repository folder",
+            ]);
+            const path = stdout.trim();
+            return path || null;
+        }
+        catch {
+            const { stdout } = await execFileAsync("kdialog", [
+                "--getexistingdirectory",
+                process.env.HOME || "/",
+                "--title",
+                "Select a repository folder",
+            ]);
+            const path = stdout.trim();
+            return path || null;
+        }
+    }
+    catch (err) {
+        const e = err;
+        // User cancel: osascript exit 1 / zenity exit 1
+        if (e.code === 1 || e.code === "1")
+            return null;
+        throw new Error(e.message ||
+            "Failed to open folder picker. On Linux install zenity or kdialog.");
+    }
+}

package/dist/shared/actionDrafts.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Drafted actions: an agent proposes integration writes (emails, messages, …)
+ * with `steer_draft_actions`; people review, edit, and Send or Discard each one
+ * in the chat. Sending runs the tool server-side; the agent never sends them.
+ */
+export type ActionDraftStatus = "draft" | "sending" | "sent" | "failed" | "discarded";
+/** Picks the card: email, a social post, a chat message, or every argument as a field. */
+export type ActionDraftKind = "email" | "reddit" | "linkedin" | "x" | "message" | "generic";
+export declare function parseActionDraftKind(value: string): ActionDraftKind;
+export interface ActionDraftInfo {
+    id: string;
+    kind: ActionDraftKind;
+    /** Bundled Integrations Hub tool, e.g. `gmail__GMAIL_SEND_EMAIL`. */
+    tool: string;
+    /** Hub provider for the logo/label, e.g. `gmail`. */
+    provider: string;
+    title: string;
+    /** Connection the action runs as, e.g. the Gmail account. */
+    fromLabel?: string;
+    args: Record<string, unknown>;
+    status: ActionDraftStatus;
+    error?: string;
+    decidedByName?: string;
+    updatedAt: number;
+}
+export declare const ACTION_DRAFTS_MAX_PER_CALL = 50;
+export declare const ACTION_DRAFT_ARGS_MAX_BYTES: number;
+/** Argument names email tools use for each field (Gmail, Outlook, generic SMTP tools). */
+export declare const EMAIL_FIELD_KEYS: {
+    readonly to: readonly ["recipient_email", "to", "to_email", "to_emails", "recipients", "recipient"];
+    readonly cc: readonly ["cc", "cc_emails", "cc_recipients"];
+    readonly bcc: readonly ["bcc", "bcc_emails", "bcc_recipients"];
+    readonly subject: readonly ["subject", "title"];
+    readonly body: readonly ["body", "message_body", "html_body", "content", "text"];
+};
+export type EmailField = keyof typeof EMAIL_FIELD_KEYS;
+/** The argument key holding `field`, if the args have one. */
+export declare function emailFieldKey(args: Record<string, unknown>, field: EmailField): string | undefined;
+/** Address lists may be a string or an array; show them as "a, b". */
+export declare function emailFieldText(value: unknown): string;
+/** Write an edited field back in the shape the tool sent it (array stays array). */
+export declare function emailFieldValue(previous: unknown, text: string): unknown;
+/** Argument names social tools use. The first key present in the args wins. */
+export declare const SOCIAL_FIELD_KEYS: {
+    readonly reddit: {
+        readonly subreddit: readonly ["subreddit", "sr", "subreddit_name"];
+        readonly title: readonly ["title"];
+        readonly body: readonly ["text", "body", "selftext", "markdown", "md"];
+        readonly link: readonly ["url", "link", "link_url"];
+        readonly replyTo: readonly ["thing_id", "parent_id", "parent", "post_id"];
+    };
+    readonly linkedin: {
+        readonly body: readonly ["commentary", "text", "comment", "comment_text", "message"];
+        readonly visibility: readonly ["visibility", "visibility_enum"];
+        readonly link: readonly ["url", "article_url", "link", "link_url"];
+        readonly author: readonly ["author", "actor"];
+    };
+    readonly x: {
+        readonly body: readonly ["text", "tweet", "status"];
+        readonly replyTo: readonly ["reply_in_reply_to_tweet_id", "in_reply_to_tweet_id", "reply_to"];
+        readonly quote: readonly ["quote_tweet_id"];
+    };
+};
+export declare const SOCIAL_LIMITS: {
+    readonly x: 280;
+    readonly linkedin: 3000;
+    readonly redditTitle: 300;
+};
+/** The argument key holding one of `keys`, if the args have it. */
+export declare function argKey(args: Record<string, unknown>, keys: readonly string[]): string | undefined;
+/** Reddit, LinkedIn, or X when the call is actually a post or reply. */
+export declare function socialDraftKind(tool: string, args: Record<string, unknown>): "reddit" | "linkedin" | "x" | null;
+export declare function actionDraftKind(tool: string, args: Record<string, unknown>): ActionDraftKind;
+export declare function isActionDraftOpen(status: ActionDraftStatus): boolean;
+/** `messages.action_drafts_json` → drafts shown on that message. */
+export declare function parseActionDraftsJson(raw: unknown): ActionDraftInfo[] | undefined;
+/** Editable text for one argument: strings as-is, address lists as "a, b", anything else as JSON. */
+export declare function draftFieldText(value: unknown): string;
+/**
+ * Rebuild the tool arguments from edited field texts, keeping each argument's
+ * original type. Throws when a structured (JSON) field no longer parses.
+ */
+export declare function applyDraftEdits(original: Record<string, unknown>, edits: Record<string, string>): Record<string, unknown>;

package/dist/shared/actionDrafts.js

@@ -0,0 +1,169 @@
+/**
+ * Drafted actions: an agent proposes integration writes (emails, messages, …)
+ * with `steer_draft_actions`; people review, edit, and Send or Discard each one
+ * in the chat. Sending runs the tool server-side; the agent never sends them.
+ */
+const ACTION_DRAFT_KINDS = [
+    "email",
+    "reddit",
+    "linkedin",
+    "x",
+    "message",
+    "generic",
+];
+export function parseActionDraftKind(value) {
+    return ACTION_DRAFT_KINDS.includes(value) ? value : "generic";
+}
+export const ACTION_DRAFTS_MAX_PER_CALL = 50;
+export const ACTION_DRAFT_ARGS_MAX_BYTES = 64 * 1024;
+/** Argument names email tools use for each field (Gmail, Outlook, generic SMTP tools). */
+export const EMAIL_FIELD_KEYS = {
+    to: ["recipient_email", "to", "to_email", "to_emails", "recipients", "recipient"],
+    cc: ["cc", "cc_emails", "cc_recipients"],
+    bcc: ["bcc", "bcc_emails", "bcc_recipients"],
+    subject: ["subject", "title"],
+    body: ["body", "message_body", "html_body", "content", "text"],
+};
+/** The argument key holding `field`, if the args have one. */
+export function emailFieldKey(args, field) {
+    return EMAIL_FIELD_KEYS[field].find((key) => key in args);
+}
+/** Address lists may be a string or an array; show them as "a, b". */
+export function emailFieldText(value) {
+    if (Array.isArray(value))
+        return value.map((v) => String(v)).join(", ");
+    return value == null ? "" : String(value);
+}
+/** Write an edited field back in the shape the tool sent it (array stays array). */
+export function emailFieldValue(previous, text) {
+    if (Array.isArray(previous)) {
+        return text
+            .split(/[,;\n]/)
+            .map((part) => part.trim())
+            .filter(Boolean);
+    }
+    return text;
+}
+/** Argument names social tools use. The first key present in the args wins. */
+export const SOCIAL_FIELD_KEYS = {
+    reddit: {
+        subreddit: ["subreddit", "sr", "subreddit_name"],
+        title: ["title"],
+        body: ["text", "body", "selftext", "markdown", "md"],
+        link: ["url", "link", "link_url"],
+        replyTo: ["thing_id", "parent_id", "parent", "post_id"],
+    },
+    linkedin: {
+        body: ["commentary", "text", "comment", "comment_text", "message"],
+        visibility: ["visibility", "visibility_enum"],
+        link: ["url", "article_url", "link", "link_url"],
+        author: ["author", "actor"],
+    },
+    x: {
+        body: ["text", "tweet", "status"],
+        replyTo: ["reply_in_reply_to_tweet_id", "in_reply_to_tweet_id", "reply_to"],
+        quote: ["quote_tweet_id"],
+    },
+};
+export const SOCIAL_LIMITS = { x: 280, linkedin: 3000, redditTitle: 300 };
+/** The argument key holding one of `keys`, if the args have it. */
+export function argKey(args, keys) {
+    return keys.find((key) => key in args);
+}
+function toolTokens(tool) {
+    return new Set(tool
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .filter(Boolean));
+}
+/** Reddit, LinkedIn, or X when the call is actually a post or reply. */
+export function socialDraftKind(tool, args) {
+    const tokens = toolTokens(tool);
+    if (tokens.has("reddit")) {
+        return argKey(args, SOCIAL_FIELD_KEYS.reddit.body) || argKey(args, SOCIAL_FIELD_KEYS.reddit.title)
+            ? "reddit"
+            : null;
+    }
+    if (tokens.has("linkedin")) {
+        return argKey(args, SOCIAL_FIELD_KEYS.linkedin.body) ? "linkedin" : null;
+    }
+    if (tokens.has("twitter") || tokens.has("tweet") || tokens.has("x")) {
+        return argKey(args, SOCIAL_FIELD_KEYS.x.body) ? "x" : null;
+    }
+    return null;
+}
+export function actionDraftKind(tool, args) {
+    const social = socialDraftKind(tool, args);
+    if (social)
+        return social;
+    const name = tool.toLowerCase();
+    if (/(mail|email|outlook)/.test(name) && emailFieldKey(args, "to") && emailFieldKey(args, "body")) {
+        return "email";
+    }
+    if (/(message|post|chat|send|reply|comment)/.test(name) && ("text" in args || "message" in args)) {
+        return "message";
+    }
+    return "generic";
+}
+export function isActionDraftOpen(status) {
+    return status === "draft" || status === "failed";
+}
+/** `messages.action_drafts_json` → drafts shown on that message. */
+export function parseActionDraftsJson(raw) {
+    if (typeof raw !== "string" || !raw)
+        return undefined;
+    try {
+        const parsed = JSON.parse(raw);
+        return Array.isArray(parsed) && parsed.length ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function isStringList(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+/** Editable text for one argument: strings as-is, address lists as "a, b", anything else as JSON. */
+export function draftFieldText(value) {
+    if (value == null)
+        return "";
+    if (typeof value === "string")
+        return value;
+    if (isStringList(value))
+        return value.join(", ");
+    return JSON.stringify(value, null, 2);
+}
+/**
+ * Rebuild the tool arguments from edited field texts, keeping each argument's
+ * original type. Throws when a structured (JSON) field no longer parses.
+ */
+export function applyDraftEdits(original, edits) {
+    const next = { ...original };
+    for (const [key, text] of Object.entries(edits)) {
+        const previous = original[key];
+        if (previous == null || typeof previous === "string") {
+            next[key] = text;
+        }
+        else if (isStringList(previous)) {
+            next[key] = emailFieldValue(previous, text);
+        }
+        else if (typeof previous === "number") {
+            const parsed = Number(text);
+            if (!Number.isFinite(parsed))
+                throw new Error(`${key} must be a number`);
+            next[key] = parsed;
+        }
+        else if (typeof previous === "boolean") {
+            next[key] = text.trim().toLowerCase() === "true";
+        }
+        else {
+            try {
+                next[key] = JSON.parse(text);
+            }
+            catch {
+                throw new Error(`${key} is not valid JSON`);
+            }
+        }
+    }
+    return next;
+}

package/dist/shared/agentArtifacts.d.ts

@@ -0,0 +1,49 @@
+/** Paths Cursor cloud agents embed for walkthrough screenshots/videos. */
+export declare function isArtifactPath(path: string): boolean;
+/**
+ * Normalize agent-facing paths to the relative form the Cloud Artifacts API accepts
+ * (e.g. `artifacts/demo.mp4`). Returns null if the path is not an artifact path.
+ */
+export declare function toRelativeArtifactPath(raw: string): string | null;
+export declare function hasArtifactRefs(text: string): boolean;
+/** Unique relative artifact paths referenced in assistant text. */
+export declare function extractArtifactPaths(text: string): string[];
+/** Assistant bubble ids for an agent that still embed unresolved artifact paths. */
+export declare function assistantIdsNeedingArtifactHydration(messages: Array<{
+    id: string;
+    role: string;
+    agentId?: string | null;
+    content?: string | null;
+}>, agentId: string): string[];
+/**
+ * Rewrite every occurrence of an absolute/relative artifact path to a served URL.
+ * Keys in `replacements` must be relative (`artifacts/foo.webp`).
+ */
+export declare function rewriteArtifactSrcs(text: string, replacements: Map<string, string>): string;
+export declare function artifactFileName(relPath: string): string;
+/** Paths from `listArtifacts()` — accept relative, absolute, or bare names. */
+export declare function normalizeListedArtifactPath(raw: string): string | null;
+export interface AgentArtifactInfo {
+    path: string;
+    name: string;
+    sizeBytes: number;
+}
+/** Cursor Cloud already writes `/opt/cursor/artifacts` and Steer hydrates those paths. */
+export declare function usesNativeCursorArtifacts(backend: string, runtime: string): boolean;
+/** Exact curl the agent must use. Raw file bytes, not base64 and not JSON. */
+export declare const ARTIFACT_CURL_UPLOAD = "curl -fsS -X POST \"$STEER_UPLOAD_URL\" -H \"Authorization: Bearer $STEER_UPLOAD_TOKEN\" -H \"Content-Type: application/octet-stream\" -H \"X-Artifact-Name: shot.png\" --data-binary @shot.png";
+/**
+ * Start-of-turn instructions for Cursor Cloud. Steer downloads
+ * `/opt/cursor/artifacts/...` after the run and shows those files to the user.
+ * Curl is included because that VM also has STEER_UPLOAD_URL.
+ */
+export declare function buildCursorArtifactRules(): string;
+/**
+ * Start-of-turn instructions for agents that do not have Cursor Cloud artifacts.
+ * Prepended to the prompt Steer sends the agent. With `autoAttach` (room chat),
+ * Steer attaches uploads to the agent's reply itself, so the model must not
+ * embed them; elsewhere (issue runs) the returned url goes in the reply.
+ */
+export declare function buildArtifactUploadRules(opts?: {
+    autoAttach?: boolean;
+}): string;

package/dist/shared/agentArtifacts.js

@@ -0,0 +1,169 @@
+/** Paths Cursor cloud agents embed for walkthrough screenshots/videos. */
+const ARTIFACT_ABS_PREFIX = "/opt/cursor/artifacts/";
+const ARTIFACT_REL_PREFIX = "artifacts/";
+/** Match src= on img/video tags, markdown images, and bare absolute artifact paths. */
+const SRC_ATTR_RE = /(?:src\s*=\s*["']([^"']+)["']|!\[[^\]]*\]\(([^)\s]+)(?:\s+"[^"]*")?\))/gi;
+const BARE_ABS_PATH_RE = /(?:^|[\s"'=(>])(\/opt\/cursor\/artifacts\/[A-Za-z0-9._\-/\u2010-\u2015]+)/g;
+export function isArtifactPath(path) {
+    const p = path.trim();
+    return (p.startsWith(ARTIFACT_ABS_PREFIX) ||
+        p.startsWith(ARTIFACT_REL_PREFIX) ||
+        p.startsWith("./artifacts/"));
+}
+/**
+ * Normalize agent-facing paths to the relative form the Cloud Artifacts API accepts
+ * (e.g. `artifacts/demo.mp4`). Returns null if the path is not an artifact path.
+ */
+export function toRelativeArtifactPath(raw) {
+    let path = raw.trim();
+    if (!path)
+        return null;
+    try {
+        if (/^https?:\/\//i.test(path)) {
+            const u = new URL(path);
+            path = u.pathname;
+        }
+    }
+    catch {
+        // keep raw
+    }
+    path = path.replace(/\\/g, "/");
+    if (path.startsWith(ARTIFACT_ABS_PREFIX)) {
+        path = ARTIFACT_REL_PREFIX + path.slice(ARTIFACT_ABS_PREFIX.length);
+    }
+    else if (path.startsWith("./artifacts/")) {
+        path = path.slice(2);
+    }
+    if (!path.startsWith(ARTIFACT_REL_PREFIX))
+        return null;
+    const rest = path.slice(ARTIFACT_REL_PREFIX.length);
+    if (!rest || rest.includes("..") || rest.startsWith("/"))
+        return null;
+    return ARTIFACT_REL_PREFIX + rest;
+}
+export function hasArtifactRefs(text) {
+    if (!text)
+        return false;
+    return (text.includes(ARTIFACT_ABS_PREFIX) ||
+        text.includes(ARTIFACT_REL_PREFIX) ||
+        text.includes("./artifacts/"));
+}
+/** Unique relative artifact paths referenced in assistant text. */
+export function extractArtifactPaths(text) {
+    if (!text || !hasArtifactRefs(text))
+        return [];
+    const found = new Set();
+    SRC_ATTR_RE.lastIndex = 0;
+    let m;
+    while ((m = SRC_ATTR_RE.exec(text)) !== null) {
+        const candidate = (m[1] || m[2] || "").trim();
+        const rel = toRelativeArtifactPath(candidate);
+        if (rel)
+            found.add(rel);
+    }
+    BARE_ABS_PATH_RE.lastIndex = 0;
+    while ((m = BARE_ABS_PATH_RE.exec(text)) !== null) {
+        const rel = toRelativeArtifactPath(m[1]);
+        if (rel)
+            found.add(rel);
+    }
+    return [...found];
+}
+/** Assistant bubble ids for an agent that still embed unresolved artifact paths. */
+export function assistantIdsNeedingArtifactHydration(messages, agentId) {
+    return messages
+        .filter((m) => m.agentId === agentId &&
+        m.role === "assistant" &&
+        hasArtifactRefs(m.content || ""))
+        .map((m) => m.id);
+}
+/**
+ * Rewrite every occurrence of an absolute/relative artifact path to a served URL.
+ * Keys in `replacements` must be relative (`artifacts/foo.webp`).
+ */
+export function rewriteArtifactSrcs(text, replacements) {
+    if (!text || replacements.size === 0)
+        return text;
+    let out = text;
+    for (const [rel, url] of replacements) {
+        const name = rel.slice(ARTIFACT_REL_PREFIX.length);
+        const variants = [
+            ARTIFACT_ABS_PREFIX + name,
+            rel,
+            "./" + rel,
+        ];
+        for (const variant of variants) {
+            if (!variant || !out.includes(variant))
+                continue;
+            out = out.split(variant).join(url);
+        }
+    }
+    return out;
+}
+export function artifactFileName(relPath) {
+    const base = relPath.split("/").pop() || "artifact";
+    return base.slice(0, 200) || "artifact";
+}
+/** Paths from `listArtifacts()` — accept relative, absolute, or bare names. */
+export function normalizeListedArtifactPath(raw) {
+    const trimmed = raw.trim().replace(/\\/g, "/");
+    if (!trimmed)
+        return null;
+    const direct = toRelativeArtifactPath(trimmed);
+    if (direct)
+        return direct;
+    const bare = trimmed.replace(/^\/+/, "");
+    if (!bare || bare.includes(".."))
+        return null;
+    return toRelativeArtifactPath(`${ARTIFACT_REL_PREFIX}${bare}`);
+}
+/** Cursor Cloud already writes `/opt/cursor/artifacts` and Steer hydrates those paths. */
+export function usesNativeCursorArtifacts(backend, runtime) {
+    return backend === "cursor" && runtime === "cloud";
+}
+/** Exact curl the agent must use. Raw file bytes, not base64 and not JSON. */
+export const ARTIFACT_CURL_UPLOAD = 'curl -fsS -X POST "$STEER_UPLOAD_URL" -H "Authorization: Bearer $STEER_UPLOAD_TOKEN" -H "Content-Type: application/octet-stream" -H "X-Artifact-Name: shot.png" --data-binary @shot.png';
+const ARTIFACT_CURL_RULES = [
+    "To upload a file, run this curl. Send the file itself. Do not base64 it, do not wrap it in JSON, and do not put the file contents on the command line:",
+    `\`${ARTIFACT_CURL_UPLOAD}\``,
+    "Put the filename in the X-Artifact-Name header. Point --data-binary at the file. This works up to 100MB.",
+    "To attach that file to a Gmail message, do not paste a link in the body. Use the curl response's artifact.url:",
+    "1. googledrive__GOOGLEDRIVE_UPLOAD_FROM_URL with source_url set to artifact.url, plus name and mime_type.",
+    "2. googledrive__GOOGLEDRIVE_DOWNLOAD_FILE with the Drive fileId from that upload (or from googledrive__GOOGLEDRIVE_FIND_FILE).",
+    "3. gmail__GMAIL_SEND_EMAIL with attachment set to an array of { name, mimetype, s3key }. name and mimetype come from the download. s3key is the path of the download's s3url after the host and before the question mark, including project_scope/. Do not pass the full signed s3url as s3key.",
+    "Example: s3url https://storage.example/project_scope/ok_1/files/report.pdf?X-Amz-Algorithm=AWS4 → s3key project_scope/ok_1/files/report.pdf.",
+];
+/**
+ * Start-of-turn instructions for Cursor Cloud. Steer downloads
+ * `/opt/cursor/artifacts/...` after the run and shows those files to the user.
+ * Curl is included because that VM also has STEER_UPLOAD_URL.
+ */
+export function buildCursorArtifactRules() {
+    return [
+        "<steer_artifacts>",
+        "When you create a file the user should look at, move it into `/opt/cursor/artifacts/` (for example `mv shot.webp /opt/cursor/artifacts/shot.webp`). Eigen shows the user the files in that folder.",
+        "Do this only when the user needs to see the file and it will not already arrive through GitHub. That means screenshots, screen recordings, mockups, diagrams, PDFs, and other artifacts you generated. Do not move source code, diffs, lockfiles, or anything else that belongs in the pull request.",
+        "In your reply, reference the moved file with its absolute path. Use an `<img>` or `<video>` tag for media, or a markdown link for other files. Example: `<img src=\"/opt/cursor/artifacts/shot.webp\" />`.",
+        ...ARTIFACT_CURL_RULES,
+        "</steer_artifacts>",
+    ].join("\n");
+}
+/**
+ * Start-of-turn instructions for agents that do not have Cursor Cloud artifacts.
+ * Prepended to the prompt Steer sends the agent. With `autoAttach` (room chat),
+ * Steer attaches uploads to the agent's reply itself, so the model must not
+ * embed them; elsewhere (issue runs) the returned url goes in the reply.
+ */
+export function buildArtifactUploadRules(opts = {}) {
+    return [
+        "<steer_artifacts>",
+        "You do not have Cursor Cloud's artifacts folder (`/opt/cursor/artifacts`). When you create a file the user should look at, upload it to Eigen.",
+        "Upload a file only when the user needs to see it and it will not already arrive through GitHub. That means screenshots, screen recordings, mockups, diagrams, PDFs, and other artifacts you generated. Do not upload source code, diffs, lockfiles, or anything else that belongs in the pull request.",
+        ...ARTIFACT_CURL_RULES,
+        opts.autoAttach
+            ? "Eigen shows every uploaded file to the user alongside your reply automatically. Mention the file by name in your reply. Do not add `<img>` or `<video>` tags, markdown images, or links for it."
+            : "Put the `url` from the upload result in your reply. Use an `<img>` or `<video>` tag for media, or a markdown link for other files.",
+        "Do not invent `/opt/cursor/artifacts/...` paths or file URLs.",
+        "</steer_artifacts>",
+    ].join("\n");
+}

package/dist/shared/agentLabel.d.ts

@@ -0,0 +1,18 @@
+/** Display name of a room agent. Kept in sync with @mentions and the sidebar. */
+export declare const AGENT_LABEL_MAX = 80;
+export declare function normalizeAgentLabel(raw: string): string;
+/**
+ * Name of the agent created with a new session.
+ * Falls back only when the session name is blank.
+ */
+export declare function initialAgentLabel(sessionName: string): string;
+export declare function resolveAgentLabel(raw: string, peers: Array<{
+    id: string;
+    label: string;
+}>, agentId: string): {
+    ok: true;
+    label: string;
+} | {
+    ok: false;
+    error: string;
+};