agent-dealer 0.0.0 → 0.1.1

package/bundle/server/dist/adapters/agent-deck.js

@@ -0,0 +1,136 @@
+import fs from "node:fs";
+import path from "node:path";
+import { getAgentDeckConfig } from "../repository/intake-settings.js";
+export function getAgentDeckApiUrl() {
+    if (process.env.AGENT_DECK_API_URL) {
+        return process.env.AGENT_DECK_API_URL.replace(/\/$/, "");
+    }
+    const cfg = getAgentDeckConfig();
+    return `http://${cfg.host}:${cfg.port}`;
+}
+export function getAgentDeckMcpUrl() {
+    if (process.env.AGENT_DECK_API_URL) {
+        const api = getAgentDeckApiUrl();
+        try {
+            const u = new URL(api);
+            const mcpPort = Number(u.port) - 1;
+            return `${u.protocol}//${u.hostname}:${mcpPort}`;
+        }
+        catch {
+            return "http://127.0.0.1:1110";
+        }
+    }
+    const cfg = getAgentDeckConfig();
+    return `http://${cfg.host}:${cfg.port - 1}`;
+}
+export async function checkAgentDeckHealth() {
+    try {
+        const res = await fetch(`${getAgentDeckApiUrl()}/health`, { signal: AbortSignal.timeout(2000) });
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}
+export async function testAgentDeckConnection() {
+    const apiUrl = getAgentDeckApiUrl();
+    const mcpUrl = getAgentDeckMcpUrl();
+    const envOverride = Boolean(process.env.AGENT_DECK_API_URL);
+    try {
+        const health = await fetch(`${apiUrl}/health`, { signal: AbortSignal.timeout(2000) });
+        if (!health.ok) {
+            return {
+                connected: false,
+                apiUrl,
+                mcpUrl,
+                envOverride,
+                error: `HTTP ${health.status}`,
+            };
+        }
+        let deckCount;
+        try {
+            const decksRes = await fetch(`${apiUrl}/api/decks`, { signal: AbortSignal.timeout(5000) });
+            if (decksRes.ok) {
+                const json = (await decksRes.json());
+                deckCount = json.data?.length;
+            }
+        }
+        catch {
+            /* decks optional */
+        }
+        return { connected: true, apiUrl, mcpUrl, deckCount, envOverride };
+    }
+    catch (e) {
+        return {
+            connected: false,
+            apiUrl,
+            mcpUrl,
+            envOverride,
+            error: String(e),
+        };
+    }
+}
+export async function fetchAgentDeckDecks() {
+    const res = await fetch(`${getAgentDeckApiUrl()}/api/decks`, { signal: AbortSignal.timeout(5000) });
+    if (!res.ok)
+        throw new Error(`Agent Deck API error: ${res.status}`);
+    return res.json();
+}
+const DASHBOARD_HEADERS = { "x-agent-deck-client": "dashboard" };
+export async function fetchPlaybook(playbookId) {
+    const res = await fetch(`${getAgentDeckApiUrl()}/api/playbooks/${playbookId}`, {
+        headers: DASHBOARD_HEADERS,
+        signal: AbortSignal.timeout(8000),
+    });
+    if (!res.ok)
+        throw new Error(`Agent Deck playbook fetch failed: ${res.status}`);
+    const json = (await res.json());
+    if (!json.data)
+        throw new Error("Playbook not found");
+    return json.data;
+}
+export async function updatePlaybookBody(playbookId, body) {
+    const res = await fetch(`${getAgentDeckApiUrl()}/api/playbooks/${playbookId}`, {
+        method: "PUT",
+        headers: { ...DASHBOARD_HEADERS, "Content-Type": "application/json" },
+        body: JSON.stringify({ body }),
+        signal: AbortSignal.timeout(8000),
+    });
+    if (!res.ok)
+        throw new Error(`Agent Deck playbook update failed: ${res.status}`);
+    const json = (await res.json());
+    if (!json.data)
+        throw new Error("Playbook update failed");
+    return json.data;
+}
+export function readClaudeMcpConfigPath() {
+    return process.env.CLAUDE_MCP_CONFIG ?? path.join(process.env.HOME ?? "", ".claude.json");
+}
+export function isAgentDeckMcpRegistered() {
+    try {
+        const configPath = readClaudeMcpConfigPath();
+        if (!fs.existsSync(configPath))
+            return false;
+        const raw = fs.readFileSync(configPath, "utf8");
+        const config = JSON.parse(raw);
+        const expected = new URL(getAgentDeckMcpUrl().replace(/\/mcp\/?$/, "") + "/mcp");
+        for (const [name, server] of Object.entries(config.mcpServers ?? {})) {
+            if (!name.toLowerCase().includes("agent-deck") && name !== "agent-deck")
+                continue;
+            if (!server.url)
+                continue;
+            try {
+                const u = new URL(server.url);
+                if (u.hostname === expected.hostname && u.port === expected.port)
+                    return true;
+            }
+            catch {
+                // skip invalid url
+            }
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+}

package/bundle/server/dist/adapters/agent-health.js

@@ -0,0 +1,109 @@
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import { claudeBinExists, cursorBinExists, resolveClaudeBin, resolveCursorBin, } from "../cli-env.js";
+import { checkAgentDeckHealth, isAgentDeckMcpRegistered } from "./agent-deck.js";
+const RUNTIME_CACHE_MS = 60_000;
+const runtimeIssueCache = new Map();
+function runCommand(cmd, args, timeoutMs = 8000) {
+    return new Promise((resolve) => {
+        const child = spawn(cmd, args, {
+            stdio: ["ignore", "pipe", "pipe"],
+            env: process.env,
+        });
+        let output = "";
+        const timer = setTimeout(() => {
+            child.kill("SIGTERM");
+            resolve({ ok: false, output: output || "timeout" });
+        }, timeoutMs);
+        child.stdout?.on("data", (d) => {
+            output += d.toString();
+        });
+        child.stderr?.on("data", (d) => {
+            output += d.toString();
+        });
+        child.on("error", (err) => {
+            clearTimeout(timer);
+            resolve({ ok: false, output: err.message });
+        });
+        child.on("close", (code) => {
+            clearTimeout(timer);
+            resolve({ ok: code === 0, output });
+        });
+    });
+}
+async function runtimeIssuesUncached(runtime) {
+    if (runtime === "claude_code") {
+        if (claudeBinExists())
+            return [];
+        const ver = await runCommand(resolveClaudeBin(), ["--version"]);
+        if (!ver.ok) {
+            return [{ code: "cli_missing", message: "Claude CLI not found — install Claude Code" }];
+        }
+        return [];
+    }
+    const status = await runCommand(resolveCursorBin(), ["agent", "status"]);
+    if (!status.ok && !status.output.trim() && !cursorBinExists()) {
+        return [{ code: "cli_missing", message: "Cursor CLI not found" }];
+    }
+    const out = status.output.toLowerCase();
+    if (out.includes("not logged in") || out.includes("login required") || out.includes("not authenticated")) {
+        return [{ code: "runtime_auth", message: "Run cursor agent login" }];
+    }
+    return [];
+}
+async function runtimeIssues(runtime) {
+    const cached = runtimeIssueCache.get(runtime);
+    if (cached && Date.now() - cached.at < RUNTIME_CACHE_MS) {
+        return cached.issues;
+    }
+    const issues = await runtimeIssuesUncached(runtime);
+    runtimeIssueCache.set(runtime, { at: Date.now(), issues });
+    return issues;
+}
+function agentSpecificIssues(agent, agentDeckOnline, mcpRegistered) {
+    const issues = [];
+    if (!agent.workspaceRoot) {
+        issues.push({ code: "workspace_missing", message: "Set workspace on Agents page" });
+    }
+    else if (!fs.existsSync(agent.workspaceRoot)) {
+        issues.push({
+            code: "workspace_missing",
+            message: `Workspace path not found: ${agent.workspaceRoot}`,
+        });
+    }
+    if (agent.deckId && !agentDeckOnline) {
+        issues.push({ code: "deck_offline", message: "Agent Deck offline — deck MCP unavailable" });
+    }
+    if (agent.deckId && agent.runtime === "claude_code" && agentDeckOnline && !mcpRegistered) {
+        issues.push({
+            code: "mcp_not_registered",
+            message: "Run agent-deck setup --client claude --start (Claude MCP not registered)",
+        });
+    }
+    return issues;
+}
+export async function healthForAgent(agent, agentDeckOnline, runtimeIssuesByRuntime, mcpRegistered) {
+    const runtime = runtimeIssuesByRuntime !== undefined
+        ? (runtimeIssuesByRuntime.get(agent.runtime) ?? [])
+        : await runtimeIssues(agent.runtime);
+    const deckMcpOk = mcpRegistered ?? isAgentDeckMcpRegistered();
+    const issues = [
+        ...runtime,
+        ...agentSpecificIssues(agent, agentDeckOnline, deckMcpOk),
+    ];
+    return {
+        ...agent,
+        healthy: issues.length === 0,
+        issues,
+    };
+}
+export async function listAgentsWithHealth(agents) {
+    const agentDeckOnline = await checkAgentDeckHealth();
+    const mcpRegistered = isAgentDeckMcpRegistered();
+    const runtimes = [...new Set(agents.map((a) => a.runtime))];
+    const runtimeIssuesByRuntime = new Map();
+    await Promise.all(runtimes.map(async (runtime) => {
+        runtimeIssuesByRuntime.set(runtime, await runtimeIssues(runtime));
+    }));
+    return Promise.all(agents.map((a) => healthForAgent(a, agentDeckOnline, runtimeIssuesByRuntime, mcpRegistered)));
+}

package/bundle/server/dist/adapters/external.js

@@ -0,0 +1,21 @@
+import { listLinearCandidates } from "./linear-inbox.js";
+export { checkAgentDeckHealth, fetchAgentDeckDecks } from "./agent-deck.js";
+export async function pollLinearIssues() {
+    if (process.env.LINEAR_AUTO_ENQUEUE === "1") {
+        console.warn("[linear] LINEAR_AUTO_ENQUEUE=1 is deprecated — use Intake promote");
+        return 0;
+    }
+    if (!process.env.LINEAR_API_KEY)
+        return 0;
+    try {
+        const candidates = await listLinearCandidates();
+        if (candidates.length > 0) {
+            console.log(`[linear] ${candidates.length} inbox candidate(s) — promote via Intake`);
+        }
+        return 0;
+    }
+    catch (e) {
+        console.error("[linear]", e);
+        return 0;
+    }
+}

package/bundle/server/dist/adapters/linear-inbox.js

@@ -0,0 +1,112 @@
+import { findActiveByExternalId, listRunsReadyForPlanReview } from "../repository/runs.js";
+import { getLinearIntakeConfig } from "../repository/intake-settings.js";
+const LINEAR_API = "https://api.linear.app/graphql";
+function hasApiKey() {
+    return Boolean(process.env.LINEAR_API_KEY);
+}
+async function linearQuery(query, variables) {
+    const key = process.env.LINEAR_API_KEY;
+    if (!key)
+        throw new Error("LINEAR_API_KEY not set");
+    const res = await fetch(LINEAR_API, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Authorization: key },
+        body: JSON.stringify({ query, variables }),
+    });
+    if (!res.ok)
+        throw new Error(`Linear HTTP ${res.status}: ${await res.text()}`);
+    const json = (await res.json());
+    if (json.errors?.length)
+        throw new Error(JSON.stringify(json.errors));
+    return json.data;
+}
+function nodeToCandidate(n) {
+    return {
+        id: n.id,
+        identifier: n.identifier,
+        title: n.title,
+        description: n.description,
+        url: n.url,
+        state: n.state?.name,
+        teamId: n.team?.id,
+        labels: n.labels?.nodes.map((l) => l.name) ?? [],
+    };
+}
+const ISSUE_FIELDS = `
+  id
+  identifier
+  title
+  description
+  url
+  state { name }
+  team { id }
+  labels { nodes { name } }
+`;
+export async function getLinearViewer() {
+    if (!hasApiKey())
+        return null;
+    const data = (await linearQuery(`query { viewer { id name email } }`));
+    return data.viewer;
+}
+export async function testLinearConnection() {
+    if (!hasApiKey()) {
+        return { connected: false, error: "LINEAR_API_KEY not set" };
+    }
+    try {
+        const viewer = await getLinearViewer();
+        if (!viewer)
+            return { connected: false, error: "No viewer returned" };
+        return { connected: true, viewer };
+    }
+    catch (e) {
+        return { connected: false, error: String(e) };
+    }
+}
+export function buildIssueFilter(settings, viewerId) {
+    const filter = {
+        state: { name: { in: settings.stateFilter } },
+    };
+    if (settings.teamId) {
+        filter.team = { id: { eq: settings.teamId } };
+    }
+    if (settings.assigneeMe && viewerId) {
+        filter.assignee = { id: { eq: viewerId } };
+    }
+    return filter;
+}
+function isPromoted(issueId) {
+    return findActiveByExternalId("linear", issueId) !== null;
+}
+export async function listLinearCandidates() {
+    if (!hasApiKey())
+        return [];
+    const settings = getLinearIntakeConfig();
+    let viewerId;
+    if (settings.assigneeMe) {
+        const viewer = await getLinearViewer();
+        viewerId = viewer?.id;
+        if (!viewerId)
+            return [];
+    }
+    const filter = buildIssueFilter(settings, viewerId);
+    const data = (await linearQuery(`query PollIssues($filter: IssueFilter) {
+      issues(filter: $filter, first: 30) {
+        nodes { ${ISSUE_FIELDS} }
+      }
+    }`, { filter }));
+    return data.issues.nodes
+        .filter((n) => !isPromoted(n.id))
+        .map(nodeToCandidate);
+}
+export async function getLinearIssue(issueId) {
+    const data = (await linearQuery(`query Issue($id: String!) {
+      issue(id: $id) { ${ISSUE_FIELDS} }
+    }`, { id: issueId }));
+    if (!data.issue)
+        return null;
+    return nodeToCandidate(data.issue);
+}
+/** Runs with a plan ready for human review. */
+export function listAwaitingPlanReview() {
+    return listRunsReadyForPlanReview();
+}

package/bundle/server/dist/adapters/linear-sync.js

@@ -0,0 +1,197 @@
+import { addArtifact, getLatestArtifact, listArtifacts } from "../repository/runs.js";
+import { getLinearIntakeConfig } from "../repository/intake-settings.js";
+import { getLinearIssue } from "./linear-inbox.js";
+const LINEAR_API = "https://api.linear.app/graphql";
+const STATE_BY_EVENT = {
+    // TODO(P2): configurable per team — see docs/LINEAR_INTEGRATION.md
+    planning_started: "Todo",
+    plan_approved: "In Progress",
+    review: "In Review",
+    retry: "In Progress",
+    done: "Done",
+};
+const workflowStateCache = new Map();
+function webBaseUrl() {
+    return process.env.AGENT_DEALER_WEB_URL ?? "http://localhost:2222";
+}
+async function linearMutate(query, variables) {
+    const key = process.env.LINEAR_API_KEY;
+    if (!key)
+        throw new Error("LINEAR_API_KEY not set");
+    const res = await fetch(LINEAR_API, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Authorization: key },
+        body: JSON.stringify({ query, variables }),
+    });
+    if (!res.ok)
+        throw new Error(`Linear HTTP ${res.status}: ${await res.text()}`);
+    const json = (await res.json());
+    if (json.errors?.length)
+        throw new Error(JSON.stringify(json.errors));
+    return json.data;
+}
+async function getWorkflowStates(teamId) {
+    const cached = workflowStateCache.get(teamId);
+    if (cached)
+        return cached;
+    const data = (await linearMutate(`query TeamStates($teamId: String!) {
+      team(id: $teamId) {
+        states { nodes { id name } }
+      }
+    }`, { teamId }));
+    const map = new Map();
+    for (const s of data.team?.states.nodes ?? []) {
+        map.set(s.name.toLowerCase(), s.id);
+    }
+    workflowStateCache.set(teamId, map);
+    return map;
+}
+async function commentCreate(issueId, body) {
+    await linearMutate(`mutation Comment($issueId: String!, $body: String!) {
+      commentCreate(input: { issueId: $issueId, body: $body }) { success }
+    }`, { issueId, body });
+}
+async function issueUpdateState(issueId, stateId) {
+    await linearMutate(`mutation UpdateIssue($issueId: String!, $stateId: String!) {
+      issueUpdate(id: $issueId, input: { stateId: $stateId }) { success }
+    }`, { issueId, stateId });
+}
+function planExcerpt(run) {
+    const plan = getLatestArtifact(run.id, "approved_plan");
+    if (!plan?.contentJson)
+        return "";
+    try {
+        const parsed = JSON.parse(plan.contentJson);
+        const md = parsed.markdown?.trim() ?? "";
+        return md.length > 600 ? `${md.slice(0, 600)}…` : md;
+    }
+    catch {
+        return "";
+    }
+}
+function resultExcerpt(run) {
+    const result = getLatestArtifact(run.id, "execution_result");
+    if (result?.contentJson) {
+        try {
+            const parsed = JSON.parse(result.contentJson);
+            const text = parsed.resultText?.trim() ?? "";
+            if (text)
+                return text.length > 500 ? `${text.slice(0, 500)}…` : text;
+        }
+        catch {
+            /* fall through */
+        }
+    }
+    const doc = listArtifacts(run.id).find((a) => a.kind === "document");
+    if (doc?.contentJson) {
+        try {
+            const parsed = JSON.parse(doc.contentJson);
+            const text = parsed.markdown?.trim() ?? "";
+            if (text)
+                return text.length > 500 ? `${text.slice(0, 500)}…` : text;
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    return "";
+}
+function buildComment(run, event) {
+    const label = run.externalLabel ?? run.externalId ?? run.id;
+    const link = `${webBaseUrl()}/?run=${run.id}`;
+    if (event === "planning_started") {
+        return [
+            `**agent-dealer** — planning started for ${label}`,
+            ``,
+            `_Agent is drafting a plan._`,
+            ``,
+            `[Open run](${link})`,
+        ].join("\n");
+    }
+    if (event === "plan_approved") {
+        const excerpt = planExcerpt(run);
+        return [
+            `**agent-dealer** — plan approved for ${label}`,
+            ``,
+            excerpt ? excerpt : `_Plan approved — see run for details._`,
+            ``,
+            `[Open run](${link})`,
+        ].join("\n");
+    }
+    if (event === "review") {
+        const excerpt = resultExcerpt(run);
+        return [
+            `**agent-dealer** — execution complete, awaiting review (${label})`,
+            ``,
+            excerpt ? excerpt : `_Result ready for human review._`,
+            ``,
+            `[Review run](${link})`,
+        ].join("\n");
+    }
+    if (event === "retry") {
+        return [
+            `**agent-dealer** — retry requested for ${label}`,
+            ``,
+            `_Re-executing with human feedback._`,
+            ``,
+            `[Open run](${link})`,
+        ].join("\n");
+    }
+    return [
+        `**agent-dealer** — approved and marked done (${label})`,
+        ``,
+        `[View run](${link})`,
+    ].join("\n");
+}
+function recordSyncAttempt(run, event, ok, detail) {
+    addArtifact(run.id, "linear_sync", { event, ok, at: new Date().toISOString(), ...detail }, "system");
+}
+function hasSuccessfulSync(runId, event) {
+    return listArtifacts(runId).some((a) => {
+        if (a.kind !== "linear_sync" || !a.contentJson)
+            return false;
+        try {
+            const parsed = JSON.parse(a.contentJson);
+            return parsed.event === event && parsed.ok === true;
+        }
+        catch {
+            return false;
+        }
+    });
+}
+/** Non-blocking Linear write-back — callers should `.catch()` and never fail the human action. */
+export async function syncLinearForRun(run, event) {
+    const settings = getLinearIntakeConfig();
+    if (!settings.syncEnabled || !process.env.LINEAR_API_KEY || !run.externalId) {
+        return;
+    }
+    if (event === "planning_started" && hasSuccessfulSync(run.id, event)) {
+        return;
+    }
+    const issue = await getLinearIssue(run.externalId);
+    if (!issue?.teamId) {
+        recordSyncAttempt(run, event, false, { error: "Issue or teamId not found" });
+        return;
+    }
+    const targetStateName = STATE_BY_EVENT[event];
+    const states = await getWorkflowStates(issue.teamId);
+    const stateId = states.get(targetStateName.toLowerCase());
+    try {
+        await commentCreate(run.externalId, buildComment(run, event));
+        if (stateId) {
+            await issueUpdateState(run.externalId, stateId);
+        }
+        else {
+            recordSyncAttempt(run, event, false, {
+                error: `Workflow state not found: ${targetStateName}`,
+                teamId: issue.teamId,
+            });
+            return;
+        }
+        recordSyncAttempt(run, event, true, { state: targetStateName });
+    }
+    catch (e) {
+        recordSyncAttempt(run, event, false, { error: String(e) });
+        console.error(`[linear-sync] ${event} for run ${run.id}:`, e);
+    }
+}

package/bundle/server/dist/cli-env.js

@@ -0,0 +1,62 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+/** Paths where Claude Code / Cursor CLI are commonly installed outside login-shell PATH. */
+function commonCliDirs(home) {
+    return [
+        path.join(home, ".local/bin"),
+        path.join(home, ".cursor/bin"),
+        "/opt/homebrew/bin",
+        "/usr/local/bin",
+    ];
+}
+/**
+ * Prepend common CLI install dirs to PATH.
+ * Cursor/npm dev servers often inherit a minimal PATH without ~/.local/bin from .zshrc.
+ */
+export function enrichPathForCliTools() {
+    const home = process.env.HOME ?? os.homedir();
+    const prepend = commonCliDirs(home);
+    const current = process.env.PATH ?? "";
+    const parts = [...prepend, ...current.split(path.delimiter)].filter((p, i, arr) => p.length > 0 && arr.indexOf(p) === i);
+    process.env.PATH = parts.join(path.delimiter);
+}
+function firstExisting(candidates) {
+    for (const candidate of candidates) {
+        if (fs.existsSync(candidate))
+            return candidate;
+    }
+    return null;
+}
+/** Resolve Claude Code binary — avoids PATH misses in IDE-spawned servers. */
+export function resolveClaudeBin() {
+    const home = process.env.HOME ?? os.homedir();
+    if (process.env.CLAUDE_CLI)
+        return process.env.CLAUDE_CLI;
+    return (firstExisting([
+        path.join(home, ".local/bin/claude"),
+        path.join(home, ".cursor/bin/claude"),
+        "/opt/homebrew/bin/claude",
+        "/usr/local/bin/claude",
+    ]) ?? "claude");
+}
+/** Resolve Cursor CLI binary. */
+export function resolveCursorBin() {
+    const home = process.env.HOME ?? os.homedir();
+    if (process.env.CURSOR_CLI)
+        return process.env.CURSOR_CLI;
+    return (firstExisting([
+        path.join(home, ".local/bin/cursor"),
+        path.join(home, ".cursor/bin/cursor"),
+        "/opt/homebrew/bin/cursor",
+        "/usr/local/bin/cursor",
+    ]) ?? "cursor");
+}
+export function claudeBinExists() {
+    const bin = resolveClaudeBin();
+    return bin !== "claude" ? fs.existsSync(bin) : false;
+}
+export function cursorBinExists() {
+    const bin = resolveCursorBin();
+    return bin !== "cursor" ? fs.existsSync(bin) : false;
+}