@geteigen/cli 0.0.0-stage → 3.1.0

package/dist/shared/issues.js

@@ -0,0 +1,217 @@
+export const ISSUE_STATUSES = [
+    "draft",
+    "queued",
+    "running",
+    "needs_input",
+    "in_review",
+    "done",
+    "failed",
+    "cancelled",
+];
+export const ISSUE_PRIORITIES = ["low", "medium", "high", "urgent"];
+export const DEFAULT_PICKUP_DELAY_MS = 10 * 60 * 1000;
+export const MIN_PICKUP_DELAY_MS = 0;
+export const MAX_PICKUP_DELAY_MS = 24 * 60 * 60 * 1000;
+export const DEFAULT_MAX_CONCURRENT_ISSUES = 2;
+export const MAX_CONCURRENT_ISSUES_CAP = 8;
+export const LINEAR_PROVIDER = "linear";
+export const DEFAULT_ALLOW_AGENT_SPAWN = false;
+export const DEFAULT_MAX_SPAWN_PER_BATCH = 10;
+export const MAX_SPAWN_PER_BATCH_CAP = 20;
+export const MAX_LINEAR_IMPORT_ISSUES = 20;
+export const ISSUE_LEASE_MS = 12 * 60 * 1000;
+export const ISSUE_POLL_MS = 15_000;
+export const ISSUE_HEARTBEAT_MS = 30_000;
+export const MAX_ISSUE_TITLE = 200;
+export const MAX_ISSUE_DESCRIPTION = 20_000;
+export const MAX_WRITEUP_CHARS = 80_000;
+export const MAX_ISSUE_ATTACHMENTS = 8;
+export const MAX_ISSUE_ATTACHMENT_BYTES = 8 * 1024 * 1024;
+export const MAX_ISSUE_ATTEMPTS = 3;
+export function isIssueStatus(value) {
+    return (typeof value === "string" &&
+        ISSUE_STATUSES.includes(value));
+}
+export function isIssuePriority(value) {
+    return (typeof value === "string" &&
+        ISSUE_PRIORITIES.includes(value));
+}
+export function issueSettingsScopeKey(input) {
+    const orgId = input.orgId?.trim();
+    if (orgId && orgId !== "personal")
+        return `org:${orgId}`;
+    return `user:${input.userId}`;
+}
+export function clampPickupDelayMs(raw, fallback = DEFAULT_PICKUP_DELAY_MS) {
+    const n = typeof raw === "number" ? raw : Number(raw);
+    if (!Number.isFinite(n))
+        return fallback;
+    return Math.min(MAX_PICKUP_DELAY_MS, Math.max(MIN_PICKUP_DELAY_MS, Math.round(n)));
+}
+export function clampMaxConcurrent(raw, ceiling = MAX_CONCURRENT_ISSUES_CAP) {
+    const n = typeof raw === "number" ? raw : Number(raw);
+    const cap = Number.isFinite(ceiling) && ceiling > 0 ? ceiling : MAX_CONCURRENT_ISSUES_CAP;
+    if (!Number.isFinite(n))
+        return Math.min(cap, DEFAULT_MAX_CONCURRENT_ISSUES);
+    return Math.min(cap, Math.max(1, Math.round(n)));
+}
+export function clampMaxSpawnPerBatch(raw) {
+    const n = typeof raw === "number" ? raw : Number(raw);
+    if (!Number.isFinite(n))
+        return DEFAULT_MAX_SPAWN_PER_BATCH;
+    return Math.min(MAX_SPAWN_PER_BATCH_CAP, Math.max(1, Math.round(n)));
+}
+/** `PER-9` / Linear URL tail → uppercase identifier, or null. */
+export function parseLinearIdentifier(raw) {
+    if (typeof raw !== "string")
+        return null;
+    const m = raw.trim().match(/\b([A-Z][A-Z0-9]*-\d+)\b/i);
+    return m ? m[1].toUpperCase() : null;
+}
+export function mapLinearPriority(raw) {
+    if (typeof raw === "number" && Number.isFinite(raw)) {
+        if (raw === 1)
+            return "urgent";
+        if (raw === 2)
+            return "high";
+        if (raw === 4)
+            return "low";
+        return "medium";
+    }
+    if (raw && typeof raw === "object" && "name" in raw) {
+        return mapLinearPriority(raw.name);
+    }
+    if (typeof raw === "string") {
+        const s = raw.trim().toLowerCase();
+        if (s === "urgent" || s === "1")
+            return "urgent";
+        if (s === "high" || s === "2")
+            return "high";
+        if (s === "low" || s === "4")
+            return "low";
+    }
+    return "medium";
+}
+export function parseGithubHttpsRepo(raw) {
+    const trimmed = raw.trim().replace(/\.git$/i, "");
+    const m = trimmed.match(/^https:\/\/github\.com\/([^/]+)\/([^/]+?)\/?$/i);
+    if (!m)
+        return null;
+    return `https://github.com/${m[1]}/${m[2]}`;
+}
+export function issueStatusLabel(status) {
+    switch (status) {
+        case "draft":
+            return "Draft";
+        case "queued":
+            return "Queued";
+        case "running":
+            return "Running";
+        case "needs_input":
+            return "Needs input";
+        case "in_review":
+            return "In review";
+        case "done":
+            return "Done";
+        case "failed":
+            return "Failed";
+        case "cancelled":
+            return "Cancelled";
+    }
+}
+export function canEditIssue(issue, actor) {
+    if (issue.creatorId === actor.userId)
+        return true;
+    return actor.orgRole === "owner" || actor.orgRole === "admin";
+}
+export function canQueueIssue(status) {
+    return status === "draft" || status === "failed" || status === "cancelled";
+}
+export function canCancelIssue(status) {
+    return status === "draft" || status === "queued" || status === "running";
+}
+export function canRetryIssue(status) {
+    return status === "failed" || status === "cancelled" || status === "needs_input";
+}
+/** True while the issue page should refresh itself (pickup / agent still moving). */
+export function issueStatusIsActive(status) {
+    return status === "queued" || status === "running" || status === "needs_input";
+}
+/** Unwrap a full-document markdown fence the model sometimes wraps around writeups. */
+export function sanitizeIssueWriteup(raw) {
+    let text = raw.replace(/\u0000/g, "").trim();
+    if (!text)
+        return "";
+    const fenced = text.match(/^```(?:markdown|md)?\s*\r?\n([\s\S]*?)\r?\n```\s*$/i)
+        || text.match(/^```(?:markdown|md)?\s*([\s\S]*?)```\s*$/i);
+    if (fenced?.[1])
+        text = fenced[1].trim();
+    if (text.length > MAX_WRITEUP_CHARS) {
+        text = text.slice(0, MAX_WRITEUP_CHARS).trimEnd();
+    }
+    return text;
+}
+export function looksLikeIssueWriteup(text) {
+    const trimmed = text.trim();
+    if (trimmed.length >= 80)
+        return true;
+    return /^#{1,3}\s+\S+/m.test(trimmed);
+}
+export function buildFallbackIssueWriteup(input) {
+    const desc = input.description?.trim();
+    const pr = input.prUrl?.trim();
+    return [
+        "## Summary",
+        "",
+        `The agent finished working on **${input.title}** but did not return a markdown writeup.`,
+        "",
+        desc ? `### Issue\n\n${desc}` : null,
+        pr
+            ? `### Pull request\n\n${pr}`
+            : "### Pull request\n\nNo pull request URL was captured.",
+    ]
+        .filter((part) => part !== null)
+        .join("\n");
+}
+export function buildIssueFixPrompt(input) {
+    const desc = input.description.trim() || "(no additional description)";
+    const attachments = input.attachmentNotes?.trim()
+        ? `\n\n${input.attachmentNotes.trim()}`
+        : "";
+    return [
+        `You are fixing Eigen issue ${input.issueId} in ${input.repoUrl} (base branch: ${input.startingRef}).`,
+        "",
+        `Title: ${input.title}`,
+        "",
+        "Description:",
+        desc,
+        attachments,
+        "",
+        "Rules:",
+        "- Implement the fix on a feature branch and open a pull request to the base branch.",
+        "- Pull request title/body may be short. Do not put a long writeup in the PR or in any repository file.",
+        "- Do not create or edit markdown/docs files for this issue (no ISSUE.md, WRITEUP.md, architecture notes, etc.).",
+        "- Do not ask clarifying questions. If something is ambiguous, pick the safest reasonable default and continue.",
+        "- Do not wait for a human. Finish the change and the pull request.",
+        ...(input.artifactRules?.trim() ? ["", input.artifactRules.trim()] : []),
+    ].join("\n");
+}
+export function buildIssueWriteupPrompt(input) {
+    const pr = input.prUrl?.trim()
+        ? `A pull request is at ${input.prUrl.trim()}.`
+        : "If a pull request was opened, mention it in one line; do not invent a URL.";
+    return [
+        `The code change for Eigen issue ${input.issueId} ("${input.title}") is done. ${pr}`,
+        "",
+        "Write a markdown note for the issue tracker only. Your entire reply must be that note.",
+        "Do not create or edit any files. Do not run more implementation work. Do not use tools.",
+        "Do not say you will write it later. Start with a ## heading.",
+        "",
+        "Cover:",
+        "- What the issue was",
+        "- The cause",
+        "- What you changed",
+        "",
+        "Markdown only. No JSON. No tool calls.",
+    ].join("\n");
+}

package/dist/shared/machines.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Machines: computers and VMs that run local agents (Cursor, Claude Code,
+ * Codex, OpenCode). Personal machines belong to one person (the desktop app and
+ * `eigen start` register them automatically; headless VMs connect with a
+ * setup token). Team machines belong to a workspace: owners/admins add them
+ * and choose who may run agents on them. Sessions pin agents to one machine.
+ */
+export type MachineAgentId = "cursor" | "claude" | "codex" | "opencode";
+export interface MachineAgentTool {
+    id: MachineAgentId;
+    label: string;
+    installed: boolean;
+    version?: string;
+    /** Where it was found (home shortened to ~). */
+    path?: string;
+}
+export type MachineOs = "darwin" | "linux" | "win32" | "other";
+/** What connected it: the desktop app or the CLI worker. */
+export type MachineClient = "desktop" | "cli";
+export type MachineKind = "personal" | "team";
+/** Team machines: who may run agents on it. Admins always can. */
+export type MachineVisibility = "everyone" | "admins" | "selected";
+/**
+ * Where agents on the machine get provider keys: the machine's own env / CLI
+ * sign-in, or the team's keys sent with each run (never written to disk).
+ */
+export type MachineKeyPolicy = "machine" | "team_keys";
+export interface MachineInfo {
+    id: string;
+    kind: MachineKind;
+    /** Team machines: the workspace that owns it. */
+    orgId: string | null;
+    /** Personal machines: whose it is. */
+    ownerUserId: string | null;
+    ownerName?: string | null;
+    /** Connected with a setup token (servers / VMs) rather than a signed-in app. */
+    headless: boolean;
+    visibility: MachineVisibility;
+    /** Selected-people visibility: who (only sent to people who can manage it). */
+    memberIds: string[];
+    keyPolicy: MachineKeyPolicy;
+    /** Folders agents may work in (headless/team machines). Empty = no limit. */
+    allowedRoots: string[];
+    /** The viewer can rename, change access, and revoke it. */
+    canManage: boolean;
+    name: string;
+    hostname: string;
+    os: MachineOs;
+    arch: string;
+    client: MachineClient;
+    online: boolean;
+    /** Agents running on it right now. */
+    activeRuns: number;
+    maxConcurrent: number;
+    agents: MachineAgentTool[];
+    lastSeenAt: number;
+    createdAt: number;
+}
+/** Room agents map backends onto the CLI each one needs on the machine. */
+export declare function machineToolForBackend(backend: string | null | undefined): MachineAgentId;
+export declare function machineHasBackend(machine: Pick<MachineInfo, "agents">, backend: string | null | undefined): boolean;
+export declare function parseMachineOs(value: unknown): MachineOs;
+export declare function machineOsLabel(os: MachineOs): string;
+/** A one-time setup token for connecting a headless machine (shown once). */
+export interface MachineSetupTokenInfo {
+    id: string;
+    name: string;
+    kind: MachineKind;
+    orgId: string | null;
+    visibility: MachineVisibility;
+    memberIds: string[];
+    keyPolicy: MachineKeyPolicy;
+    maxUses: number;
+    uses: number;
+    expiresAt: number;
+    createdAt: number;
+    createdBy: string;
+}
+export interface MachineSetupStep {
+    title: string;
+    command: string;
+}
+export interface MachineSetupCommands {
+    /** curl … | sh one-liner (installs agent CLIs + Eigen, connects, service). */
+    script: string;
+    /** Manual steps: PATH, agent CLIs, Eigen CLI, connect, service. */
+    manual: MachineSetupStep[];
+    /** docker run … */
+    docker: string;
+}
+export interface CreatedMachineToken {
+    token: string;
+    info: MachineSetupTokenInfo;
+    commands: MachineSetupCommands;
+}
+/** A folder on a machine, for the remote folder browser. */
+export interface MachineDirEntry {
+    name: string;
+    path: string;
+    isGitRepo: boolean;
+}
+export interface MachineDirListing {
+    path: string;
+    parent: string | null;
+    entries: MachineDirEntry[];
+    /** Allowed roots (empty = whole home directory). */
+    roots: string[];
+}
+export declare function machineVisibilityLabel(v: MachineVisibility, memberCount?: number): string;
+export declare function parseMachineVisibility(value: unknown): MachineVisibility;
+export declare function parseMachineKeyPolicy(value: unknown, kind: MachineKind): MachineKeyPolicy;
+/** Worker protocol that understands machine credentials, folder browsing, repo prep, and per-run env. */
+export declare const MACHINE_PROTOCOL = 9;
+/** First worker protocol that can run OpenCode agents and list their models. */
+export declare const OPENCODE_WORKER_PROTOCOL = 10;
+/** First worker protocol that can read a local workspace's git state and files. */
+export declare const WORKSPACE_WORKER_PROTOCOL = 11;
+/** First worker protocol that can commit, push, and switch branches from the git panel. */
+export declare const GIT_PANEL_WORKER_PROTOCOL = 12;

package/dist/shared/machines.js

@@ -0,0 +1,58 @@
+/**
+ * Machines: computers and VMs that run local agents (Cursor, Claude Code,
+ * Codex, OpenCode). Personal machines belong to one person (the desktop app and
+ * `eigen start` register them automatically; headless VMs connect with a
+ * setup token). Team machines belong to a workspace: owners/admins add them
+ * and choose who may run agents on them. Sessions pin agents to one machine.
+ */
+/** Room agents map backends onto the CLI each one needs on the machine. */
+export function machineToolForBackend(backend) {
+    if (backend === "claude-code")
+        return "claude";
+    if (backend === "codex")
+        return "codex";
+    if (backend === "opencode")
+        return "opencode";
+    return "cursor";
+}
+export function machineHasBackend(machine, backend) {
+    const tool = machineToolForBackend(backend);
+    const found = machine.agents.find((a) => a.id === tool);
+    // Older workers don't report tools — don't block them.
+    return machine.agents.length === 0 || Boolean(found?.installed);
+}
+export function parseMachineOs(value) {
+    return value === "darwin" || value === "linux" || value === "win32" ? value : "other";
+}
+export function machineOsLabel(os) {
+    if (os === "darwin")
+        return "macOS";
+    if (os === "linux")
+        return "Linux";
+    if (os === "win32")
+        return "Windows";
+    return "Unknown OS";
+}
+export function machineVisibilityLabel(v, memberCount = 0) {
+    if (v === "admins")
+        return "Admins only";
+    if (v === "selected")
+        return memberCount === 1 ? "1 person" : `${memberCount} people`;
+    return "Everyone in the workspace";
+}
+export function parseMachineVisibility(value) {
+    return value === "admins" || value === "selected" ? value : "everyone";
+}
+export function parseMachineKeyPolicy(value, kind) {
+    if (value === "machine" || value === "team_keys")
+        return value;
+    return kind === "team" ? "team_keys" : "machine";
+}
+/** Worker protocol that understands machine credentials, folder browsing, repo prep, and per-run env. */
+export const MACHINE_PROTOCOL = 9;
+/** First worker protocol that can run OpenCode agents and list their models. */
+export const OPENCODE_WORKER_PROTOCOL = 10;
+/** First worker protocol that can read a local workspace's git state and files. */
+export const WORKSPACE_WORKER_PROTOCOL = 11;
+/** First worker protocol that can commit, push, and switch branches from the git panel. */
+export const GIT_PANEL_WORKER_PROTOCOL = 12;

package/dist/shared/markdownMedia.d.ts

@@ -0,0 +1,13 @@
+export type MediaPart = {
+    kind: "md";
+    text: string;
+} | {
+    kind: "img";
+    src: string;
+    alt: string;
+} | {
+    kind: "video";
+    src: string;
+};
+/** Pull raw HTML <img>/<video> tags out so react-markdown can still render prose. */
+export declare function splitMediaHtml(content: string): MediaPart[];

package/dist/shared/markdownMedia.js

@@ -0,0 +1,41 @@
+/** Pull raw HTML <img>/<video> tags out so react-markdown can still render prose. */
+export function splitMediaHtml(content) {
+    if (!content)
+        return [];
+    const parts = [];
+    const re = /<video\b([^>]*)>(?:[\s\S]*?<\/video>)?|<img\b([^>]*)\/?>/gi;
+    let last = 0;
+    let m;
+    while ((m = re.exec(content)) !== null) {
+        if (m.index > last) {
+            parts.push({ kind: "md", text: content.slice(last, m.index) });
+        }
+        const attrs = m[1] ?? m[2] ?? "";
+        const src = readAttr(attrs, "src");
+        if (src) {
+            if (m[0].toLowerCase().startsWith("<video")) {
+                parts.push({ kind: "video", src });
+            }
+            else {
+                parts.push({
+                    kind: "img",
+                    src,
+                    alt: readAttr(attrs, "alt") || "",
+                });
+            }
+        }
+        else {
+            parts.push({ kind: "md", text: m[0] });
+        }
+        last = m.index + m[0].length;
+    }
+    if (last < content.length) {
+        parts.push({ kind: "md", text: content.slice(last) });
+    }
+    return parts.length ? parts : [{ kind: "md", text: content }];
+}
+function readAttr(attrs, name) {
+    const re = new RegExp(`${name}\\s*=\\s*(?:"([^"]*)"|'([^']*)'|([^\\s>]+))`, "i");
+    const m = attrs.match(re);
+    return (m?.[1] ?? m?.[2] ?? m?.[3] ?? "").trim();
+}

package/dist/shared/notificationText.d.ts

@@ -0,0 +1,6 @@
+/**
+ * One-line plain-text preview of an agent's markdown reply, for notification
+ * bodies. Notifications render as plain text and are truncated, so raw
+ * markdown shows up as `##`, `**` and table pipes.
+ */
+export declare function notificationPreview(text: string | null | undefined, max?: number): string;

package/dist/shared/notificationText.js

@@ -0,0 +1,38 @@
+/**
+ * One-line plain-text preview of an agent's markdown reply, for notification
+ * bodies. Notifications render as plain text and are truncated, so raw
+ * markdown shows up as `##`, `**` and table pipes.
+ */
+export function notificationPreview(text, max = 200) {
+    if (!text)
+        return "";
+    const lines = text
+        .replace(/```[\s\S]*?```/g, " ")
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        // Tables read as noise in one line; keep the prose around them.
+        .filter((line) => line && !line.startsWith("|") && !/^[-*_]{3,}$/.test(line))
+        .map((line) => line
+        .replace(/^#{1,6}\s+/, "")
+        .replace(/^>\s?/, "")
+        .replace(/^(?:[-*+]|\d+[.)])\s+/, "")
+        .replace(/^\[[ xX]\]\s+/, ""));
+    const plain = lines
+        .join(" ")
+        .replace(/!\[([^\]]*)\]\([^)]*\)/g, "$1")
+        .replace(/\[([^\]]+)\]\([^)]*\)/g, "$1")
+        .replace(/<[^>]+>/g, "")
+        .replace(/(\*\*|__)(.+?)\1/g, "$2")
+        .replace(/(^|[\s(])\*(\S(?:.*?\S)?)\*(?=[\s).,:;!?]|$)/g, "$1$2")
+        .replace(/~~(.+?)~~/g, "$1")
+        .replace(/`([^`]*)`/g, "$1")
+        // Leftovers from markdown cut off mid-span by an earlier truncation.
+        .replace(/\*\*|`/g, "")
+        // Already-flattened text (older notifications): a table became "| a | b |…".
+        .replace(/(?:^|\s)\|[^|]*\|.*$/, "")
+        .replace(/\s+/g, " ")
+        .trim();
+    if (plain.length <= max)
+        return plain;
+    return `${plain.slice(0, max - 1).trimEnd()}…`;
+}

package/dist/shared/opencodeModels.d.ts

@@ -0,0 +1,19 @@
+import type { ModelInfo } from "./events.js";
+/**
+ * OpenCode model ids are `provider/model` pairs. This is the offline fallback;
+ * local workers replace it with `opencode models` and the server can add live
+ * Anthropic / OpenAI catalog entries for the same providers.
+ */
+export declare const OPENCODE_MODELS: ModelInfo[];
+/** Cloud sandboxes need a concrete provider/model instead of `auto`. */
+export declare const DEFAULT_OPENCODE_MODEL = "anthropic/claude-sonnet-4-5";
+/** Keyless default on OpenCode's own gateway. */
+export declare const DEFAULT_OPENCODE_FREE_MODEL = "opencode/glm-5.3-flash-free";
+export declare function isOpencodeModelId(id: string): boolean;
+/** Pick a default cloud model that matches whichever provider key exists. */
+export declare function defaultOpencodeModelForKeys(keys: {
+    anthropic?: string;
+    openai?: string;
+}): string;
+/** Provider id encoded in an OpenCode model id. */
+export declare function opencodeModelProvider(id: string | null | undefined): "anthropic" | "openai" | null;

package/dist/shared/opencodeModels.js

@@ -0,0 +1,62 @@
+/**
+ * OpenCode model ids are `provider/model` pairs. This is the offline fallback;
+ * local workers replace it with `opencode models` and the server can add live
+ * Anthropic / OpenAI catalog entries for the same providers.
+ */
+export const OPENCODE_MODELS = [
+    {
+        id: "auto",
+        displayName: "Auto",
+        description: "Use the CLI's configured default model",
+    },
+    {
+        id: "anthropic/claude-sonnet-4-5",
+        displayName: "Claude Sonnet 4.5",
+        description: "Anthropic — default OpenCode coding model",
+    },
+    {
+        id: "anthropic/claude-opus-4-1",
+        displayName: "Claude Opus 4.1",
+        description: "Anthropic — strongest model for autonomous coding",
+    },
+    {
+        id: "openai/gpt-5-codex",
+        displayName: "GPT-5 Codex",
+        description: "OpenAI — Codex coding model",
+    },
+    {
+        id: "openai/gpt-5",
+        displayName: "GPT-5",
+        description: "OpenAI — general reasoning and coding",
+    },
+];
+/** Cloud sandboxes need a concrete provider/model instead of `auto`. */
+export const DEFAULT_OPENCODE_MODEL = "anthropic/claude-sonnet-4-5";
+/** Keyless default on OpenCode's own gateway. */
+export const DEFAULT_OPENCODE_FREE_MODEL = "opencode/glm-5.3-flash-free";
+export function isOpencodeModelId(id) {
+    if (id === "auto")
+        return true;
+    const slash = id.indexOf("/");
+    if (slash <= 0 || slash === id.length - 1)
+        return false;
+    const provider = id.slice(0, slash);
+    const model = id.slice(slash + 1);
+    return (/^[a-z0-9][a-z0-9._-]*$/i.test(provider) &&
+        !/\s/.test(model));
+}
+/** Pick a default cloud model that matches whichever provider key exists. */
+export function defaultOpencodeModelForKeys(keys) {
+    if (keys.anthropic?.trim())
+        return "anthropic/claude-sonnet-4-5";
+    if (keys.openai?.trim())
+        return "openai/gpt-5-codex";
+    return DEFAULT_OPENCODE_FREE_MODEL;
+}
+/** Provider id encoded in an OpenCode model id. */
+export function opencodeModelProvider(id) {
+    const provider = (id || "").trim().split("/")[0]?.toLowerCase();
+    if (provider === "anthropic" || provider === "openai")
+        return provider;
+    return null;
+}

package/dist/shared/opencodeSession.d.ts

@@ -0,0 +1,7 @@
+/**
+ * OpenCode scopes sessions to the project directory, and
+ * `opencode run --session <id>` for a session from another project never
+ * prints or exits. Returns false only when the list loaded and lacks the id,
+ * so a slow or broken CLI still resumes as before.
+ */
+export declare function opencodeSessionInDirectory(cwd: string, sessionId: string, env: NodeJS.ProcessEnv): Promise<boolean>;

package/dist/shared/opencodeSession.js

@@ -0,0 +1,30 @@
+import { execFile } from "child_process";
+const SESSION_LIST_TIMEOUT_MS = 15_000;
+/**
+ * OpenCode scopes sessions to the project directory, and
+ * `opencode run --session <id>` for a session from another project never
+ * prints or exits. Returns false only when the list loaded and lacks the id,
+ * so a slow or broken CLI still resumes as before.
+ */
+export function opencodeSessionInDirectory(cwd, sessionId, env) {
+    return new Promise((resolve) => {
+        execFile("opencode", ["session", "list", "--format", "json", "-n", "500"], {
+            cwd,
+            env: { ...env, PWD: cwd },
+            timeout: SESSION_LIST_TIMEOUT_MS,
+            maxBuffer: 16 * 1024 * 1024,
+        }, (err, stdout) => {
+            if (err)
+                return resolve(true);
+            try {
+                const list = JSON.parse(String(stdout));
+                if (!Array.isArray(list))
+                    return resolve(true);
+                resolve(list.some((s) => s?.id === sessionId));
+            }
+            catch {
+                resolve(true);
+            }
+        });
+    });
+}

package/dist/shared/orchestration.d.ts

@@ -0,0 +1,58 @@
+import type { IssueInfo } from "./issues.js";
+export declare const ORCHESTRATION_BATCH_KINDS: readonly ["linear_import", "spawn_issue", "spawn_room_agent"];
+export type OrchestrationBatchKind = (typeof ORCHESTRATION_BATCH_KINDS)[number];
+export declare const ORCHESTRATION_ITEM_OUTCOMES: readonly ["created", "skipped", "spawned", "assigned", "error"];
+export type OrchestrationItemOutcome = (typeof ORCHESTRATION_ITEM_OUTCOMES)[number];
+export interface OrchestrationBatchItemInfo {
+    id: string;
+    batchId: string;
+    issueId?: string | null;
+    agentId?: string | null;
+    externalProvider?: string | null;
+    externalId?: string | null;
+    externalIdentifier?: string | null;
+    externalUrl?: string | null;
+    title: string;
+    outcome: OrchestrationItemOutcome;
+    error?: string | null;
+    createdAt: number;
+}
+export interface OrchestrationBatchInfo {
+    id: string;
+    roomId?: string | null;
+    orgId?: string | null;
+    creatorId: string;
+    title: string;
+    kind: OrchestrationBatchKind;
+    status: string;
+    createdAt: number;
+    updatedAt: number;
+    items: OrchestrationBatchItemInfo[];
+}
+export interface LinearIssueSnapshot {
+    id?: string;
+    identifier?: string;
+    title?: string;
+    description?: string;
+    url?: string;
+    priority?: unknown;
+}
+export interface LinearImportResult {
+    batch: OrchestrationBatchInfo;
+    created: IssueInfo[];
+    skipped: IssueInfo[];
+    errors: Array<{
+        ref: string;
+        error: string;
+    }>;
+}
+export interface LinearIssuePreview {
+    id?: string;
+    identifier?: string;
+    title: string;
+    description?: string;
+    url?: string;
+    priority?: string;
+    alreadyImported?: boolean;
+    existingIssueId?: string;
+}