trxa-tool 0.1.1 → 0.2.0

package/dist/mcp-bridge.js

@@ -0,0 +1,290 @@
+/**
+ * `trxa mcp-bridge`: a stdio MCP server that forwards every message to a Dynamics 365 finance and
+ * operations environment's MCP endpoint (`<environment URL>/mcp`, streamable HTTP), signing in as a
+ * Microsoft Entra app registration (client credentials).
+ *
+ * Agent CLIs (GitHub Copilot CLI, Claude Code) start it as a local server named `d365-erp-mcp`.
+ * Neither CLI is on the environment's default "Allowed MCP clients" list, and a replay runs
+ * unattended, so a registered app with its own D365 user is the setup SETUP.md documents.
+ *
+ * Besides forwarding, it keeps a long replay alive across environment restarts:
+ * - every request has a timeout, and connections are never reused, so a recycled server can't
+ *   leave a request hanging on a dead socket;
+ * - when the server loses the session, it opens a new one by replaying the client's `initialize`
+ *   handshake, then retries;
+ * - it replays a request only when that is safe: the server rejected it without running it
+ *   (session not found, 401, 408/429/502/503/504), or the tool only reads. A tool call that timed
+ *   out may have run, so it is answered with an error instead of being replayed;
+ * - every request with an id gets an answer, a JSON-RPC error when all else fails.
+ *
+ * stdout carries only JSON-RPC messages; diagnostics go to stderr.
+ */
+import https from "node:https";
+import readline from "node:readline";
+const TRANSIENT_STATUS = new Set([408, 429, 502, 503, 504]);
+/** Methods that only read, so replaying them after a timeout is harmless. */
+const SAFE_METHODS = new Set(["initialize", "ping", "tools/list", "resources/list", "resources/templates/list", "prompts/list"]);
+/** Tools that only read. */
+const READ_ONLY_TOOL = /^(get_current_user|data_find_|data_get_|form_find_|api_find_)/;
+const SESSION_LOST = /session.*(could not be found|not found|expired)/i;
+/** The JSON-RPC messages in a JSON or server-sent-events body; anything else (HTML) is skipped. */
+export function parseMessages(body) {
+    const messages = [];
+    for (const raw of (body || "").split("\n")) {
+        const line = raw.startsWith("data: ") ? raw.slice(6) : raw;
+        if (!line.trim() || line.startsWith(":") || line.startsWith("event:") || line.startsWith("id:"))
+            continue;
+        try {
+            messages.push(JSON.parse(line));
+        }
+        catch {
+            // not JSON
+        }
+    }
+    return messages;
+}
+export function isReplaySafe(message) {
+    if (!message?.method)
+        return false;
+    if (SAFE_METHODS.has(message.method))
+        return true;
+    return message.method === "tools/call" && READ_ONLY_TOOL.test(message.params?.name ?? "");
+}
+function isSessionLost(response) {
+    if (response.status === 404)
+        return true;
+    if (response.status >= 400)
+        return SESSION_LOST.test(response.body || "");
+    // A 2xx counts only when it carries a JSON-RPC *error* about the session: a tool result that
+    // merely mentions those words must not trigger a replay.
+    return parseMessages(response.body).some((m) => m.error && SESSION_LOST.test(m.error.message || ""));
+}
+/** The message-handling core, independent of stdio, HTTPS and MSAL. */
+export function createBridge(deps, options = {}) {
+    const requestTimeoutMs = options.requestTimeoutMs ?? 90000;
+    const initializeTimeoutMs = options.initializeTimeoutMs ?? 25000;
+    const retryDelaysMs = options.retryDelaysMs ?? [5000, 15000, 30000];
+    let sessionId = null;
+    let initializeLine = null; // replayed to open a new session
+    let initializedLine = null; // notifications/initialized, replayed after it
+    let reopening = null; // shared, so concurrent requests reopen only once
+    async function post(body, session, timeoutMs) {
+        return deps.post(body, session, await deps.getToken(false), timeoutMs);
+    }
+    function reopenSession() {
+        if (!initializeLine)
+            return Promise.reject(new Error("no initialize request to replay"));
+        if (!reopening) {
+            const init = initializeLine;
+            reopening = (async () => {
+                deps.log(`opening a new session (previous: ${sessionId || "none"})`);
+                sessionId = null;
+                const response = await post(init, null, initializeTimeoutMs);
+                if (response.status < 200 || response.status >= 300 || !response.sessionId) {
+                    throw new Error(`initialize returned HTTP ${response.status}`);
+                }
+                sessionId = response.sessionId;
+                if (initializedLine)
+                    await post(initializedLine, sessionId, requestTimeoutMs);
+                deps.log(`new session ${sessionId}`);
+            })().finally(() => {
+                reopening = null;
+            });
+        }
+        return reopening;
+    }
+    async function send(line, message) {
+        const isInitialize = message?.method === "initialize";
+        const replaySafe = isReplaySafe(message);
+        let tokenRefreshed = false;
+        let sessionReopened = false;
+        for (let attempt = 0;; attempt++) {
+            const canRetry = attempt < retryDelaysMs.length && !isInitialize;
+            if (reopening)
+                await reopening.catch(() => { });
+            let response;
+            try {
+                response = await post(line, isInitialize ? null : sessionId, isInitialize ? initializeTimeoutMs : requestTimeoutMs);
+            }
+            catch (err) {
+                // Network error or timeout: the environment may be restarting, and the session is suspect.
+                const text = err instanceof Error ? err.message : String(err);
+                deps.log(`${message?.method ?? "request"} failed: ${text}`);
+                if (!canRetry)
+                    throw err;
+                await deps.sleep(retryDelaysMs[attempt]);
+                try {
+                    await reopenSession();
+                    sessionReopened = true;
+                }
+                catch (e) {
+                    deps.log(`reopen failed: ${e instanceof Error ? e.message : String(e)}`);
+                }
+                if (!replaySafe) {
+                    throw new Error(`${text}. The connection to D365 was lost (restart or deploy?); ` +
+                        `${sessionReopened ? "a new session is open" : "reconnecting"}. This call may or may not have run: check before retrying it.`);
+                }
+                continue;
+            }
+            if (response.status === 401 && !tokenRefreshed) {
+                deps.log("401: refreshing the token and retrying");
+                tokenRefreshed = true;
+                await deps.getToken(true);
+                continue;
+            }
+            if (response.status === 401)
+                throw new Error("authentication failed (401) after refreshing the token");
+            if (!isInitialize && sessionId && isSessionLost(response) && !sessionReopened) {
+                // The server rejected the call without running it: safe to replay on a new session.
+                deps.log(`session ${sessionId} lost (HTTP ${response.status})`);
+                try {
+                    await reopenSession();
+                    sessionReopened = true;
+                    continue;
+                }
+                catch (e) {
+                    deps.log(`reopen failed: ${e instanceof Error ? e.message : String(e)}`);
+                    if (!canRetry)
+                        throw e;
+                    await deps.sleep(retryDelaysMs[attempt]);
+                    continue;
+                }
+            }
+            if (TRANSIENT_STATUS.has(response.status)) {
+                deps.log(`HTTP ${response.status}${canRetry ? `, retrying in ${retryDelaysMs[attempt] / 1000} s` : ""}`);
+                if (!canRetry)
+                    throw new Error(`HTTP ${response.status} from D365 after ${attempt + 1} attempts`);
+                await deps.sleep(retryDelaysMs[attempt]);
+                continue;
+            }
+            if (isInitialize || response.sessionId)
+                sessionId = response.sessionId || sessionId;
+            return response;
+        }
+    }
+    function writeError(id, text) {
+        deps.write(JSON.stringify({ jsonrpc: "2.0", id, error: { code: -32000, message: `d365-erp-mcp: ${text}` } }));
+    }
+    /** Handles one line from the client; resolves once its answer (if any) is written. */
+    async function handle(line) {
+        let message = null;
+        try {
+            message = JSON.parse(line);
+        }
+        catch {
+            // forwarded as-is
+        }
+        const id = message && message.id !== undefined && message.id !== null ? message.id : null;
+        if (message?.method === "initialize") {
+            initializeLine = line;
+            sessionId = null;
+        }
+        if (message?.method === "notifications/initialized")
+            initializedLine = line;
+        try {
+            const response = await send(line, message);
+            const messages = parseMessages(response.body);
+            for (const m of messages)
+                deps.write(JSON.stringify(m));
+            if (id !== null && messages.length === 0) {
+                writeError(id, `HTTP ${response.status} without a JSON-RPC response: ${(response.body || "").slice(0, 200)}`);
+            }
+        }
+        catch (err) {
+            const text = err instanceof Error ? err.message : String(err);
+            deps.log(`error: ${text}`);
+            if (id !== null)
+                writeError(id, text);
+        }
+    }
+    return { handle };
+}
+/** Reads the bridge settings from the environment variables SETUP.md documents. */
+export function configFromEnv(env) {
+    const missing = ["D365_URL", "D365_TENANT_ID", "D365_CLIENT_ID", "D365_CLIENT_SECRET"].filter((k) => !env[k]?.trim());
+    if (missing.length > 0) {
+        throw new Error(`trxa mcp-bridge: set ${missing.join(", ")} in the MCP server's "env" settings (see SETUP.md).`);
+    }
+    let url;
+    try {
+        url = new URL(env.D365_URL.trim());
+    }
+    catch {
+        throw new Error(`trxa mcp-bridge: D365_URL is not a URL: ${env.D365_URL}`);
+    }
+    if (url.protocol !== "https:")
+        throw new Error("trxa mcp-bridge: D365_URL must start with https://");
+    return {
+        // Accept the address as copied from the browser: drop any path, query or trailing /mcp.
+        environmentUrl: `${url.protocol}//${url.host}`,
+        tenantId: env.D365_TENANT_ID.trim(),
+        clientId: env.D365_CLIENT_ID.trim(),
+        clientSecret: env.D365_CLIENT_SECRET.trim(),
+        requestTimeoutMs: Number(env.D365_MCP_TIMEOUT_MS) || 90000,
+    };
+}
+function httpsPost(mcpUrl, body, sessionId, token, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        const headers = {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${token}`,
+            Accept: "application/json, text/event-stream",
+            "Content-Length": Buffer.byteLength(body),
+        };
+        if (sessionId)
+            headers["Mcp-Session-Id"] = sessionId;
+        const req = https.request(
+        // A new connection per request: no stale pooled sockets after a restart.
+        { hostname: mcpUrl.hostname, path: mcpUrl.pathname, method: "POST", headers, agent: false }, (res) => {
+            const next = res.headers["mcp-session-id"];
+            let data = "";
+            res.setEncoding("utf8");
+            res.on("data", (chunk) => (data += chunk));
+            res.on("end", () => resolve({ body: data, sessionId: (Array.isArray(next) ? next[0] : next) || sessionId, status: res.statusCode ?? 0 }));
+            res.on("error", reject);
+        });
+        req.setTimeout(timeoutMs, () => req.destroy(new Error(`no response within ${timeoutMs / 1000} s`)));
+        req.on("error", reject);
+        req.write(body);
+        req.end();
+    });
+}
+/** `trxa mcp-bridge`: runs until stdin closes. */
+export async function runMcpBridge(env = process.env) {
+    const config = configFromEnv(env);
+    const { ConfidentialClientApplication } = await import("@azure/msal-node");
+    const msal = new ConfidentialClientApplication({
+        auth: { clientId: config.clientId, authority: `https://login.microsoftonline.com/${config.tenantId}`, clientSecret: config.clientSecret },
+    });
+    const scopes = [`${config.environmentUrl}/.default`];
+    const mcpUrl = new URL(`${config.environmentUrl}/mcp`);
+    let token = null;
+    let expires = 0;
+    const log = (text) => process.stderr.write(`[trxa mcp-bridge ${new Date().toISOString()}] ${text}\n`);
+    const deps = {
+        async getToken(forceRefresh) {
+            if (!forceRefresh && token && Date.now() < expires - 60000)
+                return token;
+            const result = await msal.acquireTokenByClientCredential({ scopes, skipCache: forceRefresh });
+            if (!result?.accessToken)
+                throw new Error("Microsoft Entra ID returned no access token");
+            token = result.accessToken;
+            expires = result.expiresOn ? result.expiresOn.getTime() : Date.now() + 300000;
+            return token;
+        },
+        post: (body, sessionId, accessToken, timeoutMs) => httpsPost(mcpUrl, body, sessionId, accessToken, timeoutMs),
+        write: (line) => process.stdout.write(line + "\n"),
+        log,
+        sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+    };
+    const bridge = createBridge(deps, { requestTimeoutMs: config.requestTimeoutMs });
+    log(`forwarding to ${mcpUrl.href}`);
+    // Warm the token without blocking startup: the client's connect timeout is short.
+    deps.getToken(false).then(() => log("signed in to Microsoft Entra ID"), (err) => log(`not signed in yet: ${err instanceof Error ? err.message : String(err)}`));
+    const rl = readline.createInterface({ input: process.stdin });
+    rl.on("line", (line) => {
+        if (line.trim())
+            void bridge.handle(line);
+    });
+    await new Promise((resolve) => rl.on("close", () => resolve()));
+}

package/dist/planrun-schema.d.ts

@@ -1,10 +1,10 @@
 /**
  * A PlanRun is the thin, persisted record that gives a Test Plan's execution a real identity --
- * `{id, planId, startedAt, suiteIds}`. It deliberately carries no name or purpose of its own: that
- * would duplicate what the TestPlan it belongs to already owns. Every reference tool checked
- * before settling this shape (TestRail, Zephyr, Azure DevOps Test Plans) converges on the same
- * pattern -- Plan-as-anchor, Run-as-dated-instance, distinguished from sibling runs only by when
- * it started.
+ * `{id, planId, startedAt, suiteIds}`. The plan stays the anchor and the run a dated instance of
+ * it, but a run can also carry an optional `name` of its own. People refer to a run by what it
+ * tested ("Accounts Payable regression, PQU 10.0.48"), not by its start time, and TestRail and
+ * Azure DevOps Test Plans both let a run be named for that reason. The name never replaces the
+ * plan's identity: `planId` still says which plan it ran.
  *
  * `suiteIds` is a snapshot of the plan's suite composition at the moment the run started --
  * confirmed live that a PlanRun without one breaks: adding "create-new-vendor" as a second suite
@@ -30,7 +30,15 @@ export interface PlanRun {
     startedAt: string;
     suiteIds: string[];
     suiteNames: Record<string, string>;
+    /** What people call this run, e.g. "Accounts Payable regression, PQU 10.0.48". Optional: a run
+     *  without one is shown by its plan's name and start time. */
+    name?: string;
 }
+/** Longest run name accepted, so a pasted paragraph can't end up as a list label. */
+export declare const RUN_NAME_MAX_LENGTH = 120;
+/** Trims a run name and checks its length; an empty name means "no name". Shared by the plan run
+ *  and test run schemas, the CLI's `--name` flag and Studio's rename endpoints. */
+export declare function normalizeRunName(value: unknown, field?: string): string | undefined;
 /** Colons aren't legal in Windows filenames, so `id` is `startedAt` with them swapped for dashes
  *  -- still lexically sortable, still human-readable, and trivially derivable from `startedAt`
  *  rather than needing a separate id-generation scheme. A caller never invents this string
@@ -41,5 +49,5 @@ export interface PlanRun {
 export declare function createPlanRun(planId: string, suites: {
     id: string;
     name: string;
-}[]): PlanRun;
+}[], name?: string): PlanRun;
 export declare function validatePlanRun(value: unknown): PlanRun;

package/dist/planrun-schema.js

@@ -1,10 +1,10 @@
 /**
  * A PlanRun is the thin, persisted record that gives a Test Plan's execution a real identity --
- * `{id, planId, startedAt, suiteIds}`. It deliberately carries no name or purpose of its own: that
- * would duplicate what the TestPlan it belongs to already owns. Every reference tool checked
- * before settling this shape (TestRail, Zephyr, Azure DevOps Test Plans) converges on the same
- * pattern -- Plan-as-anchor, Run-as-dated-instance, distinguished from sibling runs only by when
- * it started.
+ * `{id, planId, startedAt, suiteIds}`. The plan stays the anchor and the run a dated instance of
+ * it, but a run can also carry an optional `name` of its own. People refer to a run by what it
+ * tested ("Accounts Payable regression, PQU 10.0.48"), not by its start time, and TestRail and
+ * Azure DevOps Test Plans both let a run be named for that reason. The name never replaces the
+ * plan's identity: `planId` still says which plan it ran.
  *
  * `suiteIds` is a snapshot of the plan's suite composition at the moment the run started --
  * confirmed live that a PlanRun without one breaks: adding "create-new-vendor" as a second suite
@@ -24,6 +24,21 @@
  * file's only job is to make that id a real, validated, directly-queryable record instead of an
  * unvalidated convention nobody checks.
  */
+/** Longest run name accepted, so a pasted paragraph can't end up as a list label. */
+export const RUN_NAME_MAX_LENGTH = 120;
+/** Trims a run name and checks its length; an empty name means "no name". Shared by the plan run
+ *  and test run schemas, the CLI's `--name` flag and Studio's rename endpoints. */
+export function normalizeRunName(value, field = "name") {
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value !== "string")
+        throw new Error(`Invalid run name: ${field} must be a string`);
+    const name = value.trim().replace(/\s+/g, " ");
+    if (name.length > RUN_NAME_MAX_LENGTH) {
+        throw new Error(`Invalid run name: ${field} must be at most ${RUN_NAME_MAX_LENGTH} characters`);
+    }
+    return name || undefined;
+}
 /** Colons aren't legal in Windows filenames, so `id` is `startedAt` with them swapped for dashes
  *  -- still lexically sortable, still human-readable, and trivially derivable from `startedAt`
  *  rather than needing a separate id-generation scheme. A caller never invents this string
@@ -31,14 +46,16 @@
  *  arbitrary, unvalidated string a human or LLM picked by hand. `suites` is captured from the plan
  *  as it exists right now, at creation time -- never re-derived later -- and split into the two
  *  snapshot fields above. */
-export function createPlanRun(planId, suites) {
+export function createPlanRun(planId, suites, name) {
     const startedAt = new Date().toISOString();
+    const runName = normalizeRunName(name);
     return {
         id: startedAt.replace(/:/g, "-"),
         planId,
         startedAt,
         suiteIds: suites.map((s) => s.id),
         suiteNames: Object.fromEntries(suites.map((s) => [s.id, s.name])),
+        ...(runName ? { name: runName } : {}),
     };
 }
 function fail(field, reason) {
@@ -83,5 +100,12 @@ export function validatePlanRun(value) {
     assertString(v.startedAt, "startedAt");
     const suiteIds = assertSuiteIds(v.suiteIds);
     const suiteNames = assertSuiteNames(v.suiteNames);
-    return { id: v.id, planId: v.planId, startedAt: v.startedAt, suiteIds, suiteNames };
+    let name;
+    try {
+        name = normalizeRunName(v.name);
+    }
+    catch (err) {
+        fail("name", err.message.replace(/^Invalid run name: name /, ""));
+    }
+    return { id: v.id, planId: v.planId, startedAt: v.startedAt, suiteIds, suiteNames, ...(name ? { name } : {}) };
 }

package/dist/planrun.d.ts

@@ -14,7 +14,7 @@ export declare function listPlanRuns(dir: string, planId?: string): Promise<Plan
 export declare function initPlanRun(planId: string, suites: {
     id: string;
     name: string;
-}[], dir: string): Promise<{
+}[], dir: string, name?: string): Promise<{
     planRun: PlanRun;
     filePath: string;
 }>;

package/dist/planrun.js

@@ -37,8 +37,8 @@ export async function listPlanRuns(dir, planId) {
  *  plan's current suites (id + name) -- captured once, here, so this run's status/display never
  *  drifts if the plan's suites are later added, removed, or renamed (see planrun-schema.ts's
  *  `PlanRun.suiteIds`/`suiteNames`). */
-export async function initPlanRun(planId, suites, dir) {
-    const planRun = createPlanRun(planId, suites);
+export async function initPlanRun(planId, suites, dir, name) {
+    const planRun = createPlanRun(planId, suites, name);
     const filePath = path.join(dir, `${planRun.id}.json`);
     await mkdir(dir, { recursive: true });
     await writeFile(filePath, JSON.stringify(planRun, null, 2), "utf-8");

package/dist/report-schema.d.ts

@@ -73,11 +73,20 @@ export interface TestCaseResult {
     messages?: string[];
 }
 export interface TestRun {
+    /** The suite's id -- or, for a `scope: "testcase"` run, the test case's id. */
     suiteId: string;
     startedAt: string;
     results: Record<string, TestCaseResult>;
+    /** What this run was started for. Absent on runs the CLI created for a suite (the original
+     *  behavior). `testcase` marks a run of one test case on its own, with no suite around it. */
+    scope?: "suite" | "testcase";
+    /** The Studio agent run executing this record, when one created it. */
+    agentRunId?: string;
+    /** What people call this run, e.g. "Vendor onboarding, PQU 10.0.48". Optional; a suite run that
+     *  belongs to a plan run is named by its PlanRun instead. See planrun-schema.ts's `name`. */
+    name?: string;
 }
 /** Creates a fresh TestRun with every suite entry pre-populated as "pending". */
-export declare function createTestRun(suiteId: string, testCaseIds: string[]): TestRun;
+export declare function createTestRun(suiteId: string, testCaseIds: string[], extra?: Pick<TestRun, "scope" | "agentRunId" | "name">): TestRun;
 /** Validates a parsed JSON object against the TestRun shape. */
 export declare function validateTestRun(value: unknown): TestRun;

package/dist/report-schema.js

@@ -1,5 +1,4 @@
-/** Persisted, durable record of a suite run -- this is the mechanism that answers "keep track
- *  of each test case, expected input, and actual output" instead of relying on chat memory. */
+import { normalizeRunName } from "./planrun-schema.js";
 /** Statuses a test case never leaves once reached -- used by both `suite-runner.ts` (to decide
  *  whether a whole suite run is done) and `plan-runner.ts` (to roll that up across suites).
  *  Exported from here, not duplicated in each, so the two can't drift out of sync with each other
@@ -8,12 +7,20 @@
  *  error. */
 export const TERMINAL_STATUSES = new Set(["passed", "failed", "blocked", "skipped"]);
 /** Creates a fresh TestRun with every suite entry pre-populated as "pending". */
-export function createTestRun(suiteId, testCaseIds) {
+export function createTestRun(suiteId, testCaseIds, extra = {}) {
+    const name = normalizeRunName(extra.name);
     const results = {};
     for (const id of testCaseIds) {
         results[id] = { status: "pending", outputs: {}, assertionResults: [] };
     }
-    return { suiteId, startedAt: new Date().toISOString(), results };
+    return {
+        suiteId,
+        startedAt: new Date().toISOString(),
+        results,
+        ...(extra.scope !== undefined ? { scope: extra.scope } : {}),
+        ...(extra.agentRunId !== undefined ? { agentRunId: extra.agentRunId } : {}),
+        ...(name ? { name } : {}),
+    };
 }
 function fail(field, reason) {
     throw new Error(`Invalid TestRun: ${field} ${reason}`);
@@ -85,5 +92,24 @@ export function validateTestRun(value) {
     for (const [id, result] of Object.entries(v.results)) {
         results[id] = validateTestCaseResult(result, id);
     }
-    return { suiteId: v.suiteId, startedAt: v.startedAt, results };
+    if (v.scope !== undefined && v.scope !== "suite" && v.scope !== "testcase") {
+        fail("scope", "must be suite or testcase");
+    }
+    if (v.agentRunId !== undefined && typeof v.agentRunId !== "string")
+        fail("agentRunId", "must be a string");
+    let name;
+    try {
+        name = normalizeRunName(v.name);
+    }
+    catch (err) {
+        fail("name", err.message.replace(/^Invalid run name: name /, ""));
+    }
+    return {
+        suiteId: v.suiteId,
+        startedAt: v.startedAt,
+        results,
+        ...(v.scope !== undefined ? { scope: v.scope } : {}),
+        ...(v.agentRunId !== undefined ? { agentRunId: v.agentRunId } : {}),
+        ...(name ? { name } : {}),
+    };
 }

package/dist/report.d.ts

@@ -9,7 +9,10 @@ import type { TestSuite } from "./suite-schema.js";
 export declare function readTestRun(path: string): Promise<TestRun>;
 export declare function writeTestRun(testRun: TestRun, path: string): Promise<void>;
 /** Creates and persists a fresh TestRun for a suite, with every entry pre-populated as "pending". */
-export declare function initTestRun(suite: TestSuite, path: string): Promise<TestRun>;
+export declare function initTestRun(suite: TestSuite, path: string, extra?: Pick<TestRun, "agentRunId" | "name">): Promise<TestRun>;
+/** Creates and persists a TestRun for one test case run on its own, with no suite: a single
+ *  pending entry keyed by the test case id. `recordResult` works on it unchanged. */
+export declare function initTestCaseRun(testCaseId: string, path: string, extra?: Pick<TestRun, "agentRunId" | "name">): Promise<TestRun>;
 export interface RecordResultInput {
     status: TestCaseStatus;
     outputs?: Record<string, string>;

package/dist/report.js

@@ -14,8 +14,15 @@ export async function writeTestRun(testRun, path) {
     await writeFile(path, JSON.stringify(testRun, null, 2), "utf-8");
 }
 /** Creates and persists a fresh TestRun for a suite, with every entry pre-populated as "pending". */
-export async function initTestRun(suite, path) {
-    const testRun = createTestRun(suite.id, suite.entries.map((e) => e.testCaseId));
+export async function initTestRun(suite, path, extra = {}) {
+    const testRun = createTestRun(suite.id, suite.entries.map((e) => e.testCaseId), { ...extra, scope: "suite" });
+    await writeTestRun(testRun, path);
+    return testRun;
+}
+/** Creates and persists a TestRun for one test case run on its own, with no suite: a single
+ *  pending entry keyed by the test case id. `recordResult` works on it unchanged. */
+export async function initTestCaseRun(testCaseId, path, extra = {}) {
+    const testRun = createTestRun(testCaseId, [testCaseId], { ...extra, scope: "testcase" });
     await writeTestRun(testRun, path);
     return testRun;
 }

package/dist/suite-runner.js

@@ -68,11 +68,17 @@ export function resolveInputs(entry, testCase, testRun, fixtures) {
             continue;
         }
         if (binding.kind === "fixture") {
-            const fixture = fixtures.find((f) => f.name === binding.fixtureName && f.testCaseId === testCase.id);
+            // Ignoring case: a fixture's name is also its file name, so two names differing only in
+            // case can't coexist on Windows and are the same fixture.
+            const fixture = fixtures.find((f) => f.name.toLowerCase() === binding.fixtureName.toLowerCase());
             if (!fixture) {
                 throw new Error(`Test case "${testCase.id}", param "${param.name}": no fixture named "${binding.fixtureName}" found`);
             }
-            const value = fixture.values[binding.param];
+            const values = fixture.testCases[testCase.id];
+            if (!values) {
+                throw new Error(`Test case "${testCase.id}", param "${param.name}": fixture "${binding.fixtureName}" has no values for this test case`);
+            }
+            const value = values[binding.param];
             if (value === undefined) {
                 throw new Error(`Test case "${testCase.id}", param "${param.name}": fixture "${binding.fixtureName}" has no value for "${binding.param}"`);
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trxa-tool",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "TRXA-TOOL -- extract D365 Finance & Operations Task Recorder (.axtr) files into structured test plans for LLM-driven automated testing via the d365-erp-mcp server.",
   "type": "module",
   "license": "SEE LICENSE IN LICENSE",
@@ -29,6 +29,8 @@
     "README.md",
     "MANUAL.md",
     "STUDIO.md",
+    "SETUP.md",
+    "media",
     "LICENSE"
   ],
   "scripts": {
@@ -39,10 +41,12 @@
     "studio:server": "tsx watch studio/server/index.ts",
     "studio:client": "npm run dev --prefix studio/client",
     "build:studio-client": "npm run build --prefix studio/client",
-    "build:studio-server": "esbuild studio/server/index.ts --bundle --platform=node --format=esm --outfile=studio/server/dist/index.js --external:express --external:fast-xml-parser --external:jszip",
+    "build:studio-server": "esbuild studio/server/index.ts --bundle --platform=node --format=esm --outfile=studio/server/dist/index.js --external:express --external:fast-xml-parser --external:jszip --external:@github/copilot-sdk",
     "package": "npm run build && npm run build:studio-client && npm run build:studio-server"
   },
   "dependencies": {
+    "@azure/msal-node": "^5.6.0",
+    "@github/copilot-sdk": "^1.0.26",
     "express": "^5.2.1",
     "fast-xml-parser": "^4.5.0",
     "jszip": "^3.10.1"