@dichovsky/testrail-api-client 1.0.0 → 2.1.0

package/README.md

@@ -55,6 +55,26 @@ A comprehensive, type-safe TypeScript/JavaScript client for the [TestRail API](h
 npm install @dichovsky/testrail-api-client
 ```
 
+## Using with AI Coding Agents
+
+This package ships a Claude Code skill at `skill/SKILL.md` that teaches coding agents how to use the bundled `testrail` CLI. Install it into your project (or globally) so Claude Code auto-loads it whenever you ask the agent to query or write TestRail entities.
+
+```bash
+# Install into the current project: ./.claude/skills/testrail-cli/SKILL.md
+npx testrail install-skill
+
+# Or globally: ~/.claude/skills/testrail-cli/SKILL.md
+npx testrail install-skill --global
+
+# Overwrite an existing install
+npx testrail install-skill --force
+
+# Just print the bundled SKILL.md path (for scripting / vendoring)
+npx testrail install-skill --print-path
+```
+
+The skill description triggers auto-load when an agent's prompt mentions TestRail entities (projects, suites, cases, runs, results, milestones, users) or when `TESTRAIL_BASE_URL` / `TESTRAIL_EMAIL` / `TESTRAIL_API_KEY` are set in the environment. The bundled CLI itself supports both read (`get`, `list`) and write (`add`, `update`, `add-bulk`, `close`) operations — see `skill/SKILL.md` for the complete command surface and recipes.
+
 ## Quick Start
 
 ```typescript
@@ -356,6 +376,8 @@ const priorities = await client.getPriorities();
 const milestones = await client.getMilestones(projectId);
 ```
 
+Advanced usage: the client also exposes domain modules such as `client.metadata` for organization, but the supported/documented usage pattern remains the top-level `client.getX()` methods.
+
 ### Caching
 
 The client automatically caches GET requests to improve performance:

package/dist/cli/auth.d.ts

@@ -0,0 +1,21 @@
+import type { TestRailConfig } from '../types.js';
+export interface AuthFlags {
+    baseUrl: string | undefined;
+    email: string | undefined;
+    apiKey: string | undefined;
+}
+export interface AuthEnv {
+    TESTRAIL_BASE_URL?: string;
+    TESTRAIL_EMAIL?: string;
+    TESTRAIL_API_KEY?: string;
+}
+export type AuthResolution = {
+    ok: true;
+    config: TestRailConfig;
+} | {
+    ok: false;
+    error: string;
+};
+export declare const MISSING_AUTH_MESSAGE = "Missing auth. Set TESTRAIL_BASE_URL, TESTRAIL_EMAIL, TESTRAIL_API_KEY or use --base-url, --email, --api-key flags.";
+export declare function resolveAuth(flags: AuthFlags, env: AuthEnv): AuthResolution;
+//# sourceMappingURL=auth.d.ts.map

package/dist/cli/auth.js

@@ -0,0 +1,16 @@
+export const MISSING_AUTH_MESSAGE = 'Missing auth. Set TESTRAIL_BASE_URL, TESTRAIL_EMAIL, TESTRAIL_API_KEY or use --base-url, --email, --api-key flags.';
+export function resolveAuth(flags, env) {
+    const baseUrl = flags.baseUrl ?? env.TESTRAIL_BASE_URL;
+    const email = flags.email ?? env.TESTRAIL_EMAIL;
+    const apiKey = flags.apiKey ?? env.TESTRAIL_API_KEY;
+    if (baseUrl === undefined ||
+        baseUrl === '' ||
+        email === undefined ||
+        email === '' ||
+        apiKey === undefined ||
+        apiKey === '') {
+        return { ok: false, error: MISSING_AUTH_MESSAGE };
+    }
+    return { ok: true, config: { baseUrl, email, apiKey } };
+}
+//# sourceMappingURL=auth.js.map

package/dist/cli/body.d.ts

@@ -0,0 +1,42 @@
+import type { z } from 'zod';
+import type { BodyInput } from './handler-context.js';
+/**
+ * Source of a parsed body. Reported alongside the resolution result so
+ * handlers (or callers writing recipes) can log which input mechanism the
+ * agent actually used.
+ */
+export type BodySource = 'data' | 'file' | 'stdin';
+export type BodyResolution<T> = {
+    ok: true;
+    payload: T;
+    source: BodySource;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Resolve a write-action body from one of three mutually-exclusive sources:
+ *
+ * - `--data <json-string>` (provided via `BodyInput.dataFlag`)
+ * - `--data-file <path>` (provided via `BodyInput.dataFileFlag`; read via
+ *   readFileSync so failures surface as a structured `ok: false` rather than
+ *   crashing the CLI)
+ * - stdin (provided via `BodyInput.readStdin` thunk; the caller is
+ *   responsible for non-TTY detection — only set the thunk when stdin is
+ *   piped. The resolver invokes the thunk *only* when stdin is the
+ *   selected source, so read actions and no-body writes never drain it.)
+ *
+ * After source resolution: JSON-parse the raw string, then validate against
+ * the supplied Zod schema. No coercion is applied (Q8 lock from
+ * SKILL-PLAN.md) — wrong types are rejected immediately so agent payload
+ * bugs surface at the CLI boundary rather than the API call site.
+ *
+ * Typed via `S extends z.ZodTypeAny` so the inferred payload type carries
+ * through to the caller — `resolveBody(input, AddCasePayloadSchema)` returns
+ * `BodyResolution<AddCasePayload>`, not `BodyResolution<unknown>`.
+ *
+ * @param input  raw inputs from the CLI argv + stdin reader
+ * @param schema Zod schema for the expected payload shape
+ */
+export declare function resolveBody<S extends z.ZodTypeAny>(input: BodyInput, schema: S): BodyResolution<z.infer<S>>;
+//# sourceMappingURL=body.d.ts.map

package/dist/cli/body.js

@@ -0,0 +1,89 @@
+import { readFileSync } from 'node:fs';
+/**
+ * Resolve a write-action body from one of three mutually-exclusive sources:
+ *
+ * - `--data <json-string>` (provided via `BodyInput.dataFlag`)
+ * - `--data-file <path>` (provided via `BodyInput.dataFileFlag`; read via
+ *   readFileSync so failures surface as a structured `ok: false` rather than
+ *   crashing the CLI)
+ * - stdin (provided via `BodyInput.readStdin` thunk; the caller is
+ *   responsible for non-TTY detection — only set the thunk when stdin is
+ *   piped. The resolver invokes the thunk *only* when stdin is the
+ *   selected source, so read actions and no-body writes never drain it.)
+ *
+ * After source resolution: JSON-parse the raw string, then validate against
+ * the supplied Zod schema. No coercion is applied (Q8 lock from
+ * SKILL-PLAN.md) — wrong types are rejected immediately so agent payload
+ * bugs surface at the CLI boundary rather than the API call site.
+ *
+ * Typed via `S extends z.ZodTypeAny` so the inferred payload type carries
+ * through to the caller — `resolveBody(input, AddCasePayloadSchema)` returns
+ * `BodyResolution<AddCasePayload>`, not `BodyResolution<unknown>`.
+ *
+ * @param input  raw inputs from the CLI argv + stdin reader
+ * @param schema Zod schema for the expected payload shape
+ */
+export function resolveBody(input, schema) {
+    const sources = [
+        input.dataFlag !== undefined ? 'data' : null,
+        input.dataFileFlag !== undefined ? 'file' : null,
+        input.readStdin !== undefined ? 'stdin' : null,
+    ].filter((s) => s !== null);
+    if (sources.length === 0) {
+        return {
+            ok: false,
+            error: 'Body required. Pass a JSON payload via --data <json>, --data-file <path>, or stdin pipe.',
+        };
+    }
+    if (sources.length > 1) {
+        return {
+            ok: false,
+            error: `Multiple body sources provided (${sources.join(', ')}). Use exactly one of --data, --data-file, or stdin.`,
+        };
+    }
+    let raw;
+    let source;
+    if (input.dataFlag !== undefined) {
+        raw = input.dataFlag;
+        source = 'data';
+    }
+    else if (input.dataFileFlag !== undefined) {
+        try {
+            raw = readFileSync(input.dataFileFlag, 'utf-8');
+        }
+        catch (e) {
+            return {
+                ok: false,
+                error: `Cannot read --data-file '${input.dataFileFlag}': ${e instanceof Error ? e.message : String(e)}`,
+            };
+        }
+        source = 'file';
+    }
+    else {
+        // stdin is the only remaining source. Invoke the thunk now (and only
+        // now) so the underlying readFileSync(0) call happens lazily.
+        try {
+            raw = input.readStdin();
+        }
+        catch (e) {
+            return {
+                ok: false,
+                error: `Cannot read stdin: ${e instanceof Error ? e.message : String(e)}`,
+            };
+        }
+        source = 'stdin';
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (e) {
+        return { ok: false, error: `Invalid JSON: ${e instanceof Error ? e.message : String(e)}` };
+    }
+    const result = schema.safeParse(parsed);
+    if (!result.success) {
+        return { ok: false, error: `Payload validation failed: ${result.error.message}` };
+    }
+    return { ok: true, payload: result.data, source };
+}
+//# sourceMappingURL=body.js.map

package/dist/cli/dispatch.d.ts

@@ -0,0 +1,16 @@
+import type { Handler } from './handler-context.js';
+export type DispatchResult = {
+    ok: true;
+    handler: Handler;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Returns every registered `resource:action` key. Used by the
+ * metadata↔dispatch consistency tests to catch handlers added without a
+ * matching metadata entry — the inverse of the metadata-first check.
+ */
+export declare function getRegisteredActions(): readonly string[];
+export declare function dispatch(resource: string, action: string): DispatchResult;
+//# sourceMappingURL=dispatch.d.ts.map

package/dist/cli/dispatch.js

@@ -0,0 +1,87 @@
+import { handleProjectGet, handleProjectList } from './handlers/project.js';
+import { handleSuiteGet, handleSuiteList } from './handlers/suite.js';
+import { handleCaseGet, handleCaseList } from './handlers/case.js';
+import { handleCaseAdd, handleCaseUpdate } from './handlers/case-write.js';
+import { handleRunGet, handleRunList } from './handlers/run.js';
+import { handleRunAdd, handleRunClose } from './handlers/run-write.js';
+import { handleResultList } from './handlers/result.js';
+import { handleResultAdd, handleResultAddBulk } from './handlers/result-write.js';
+import { handleMilestoneGet, handleMilestoneList } from './handlers/milestone.js';
+import { handleUserGet, handleUserList } from './handlers/user.js';
+/**
+ * Single source of truth: every supported resource:action mapped to its handler.
+ * Adding an action is a one-line change here — no parallel registry to keep in
+ * sync. `dispatch()` derives both the known-resources list and the
+ * known-actions-per-resource list from this map's keys, so error wording stays
+ * accurate even as the map evolves.
+ *
+ * Keys are inserted in the canonical display order (`get` before `list`, etc.);
+ * JavaScript object iteration order is insertion-order-preserving for string
+ * keys, which keeps error messages stable.
+ */
+const HANDLERS = {
+    'project:get': handleProjectGet,
+    'project:list': handleProjectList,
+    'suite:get': handleSuiteGet,
+    'suite:list': handleSuiteList,
+    'case:get': handleCaseGet,
+    'case:list': handleCaseList,
+    'case:add': handleCaseAdd,
+    'case:update': handleCaseUpdate,
+    'run:get': handleRunGet,
+    'run:list': handleRunList,
+    'run:add': handleRunAdd,
+    'run:close': handleRunClose,
+    'result:list': handleResultList,
+    'result:add': handleResultAdd,
+    'result:add-bulk': handleResultAddBulk,
+    'milestone:get': handleMilestoneGet,
+    'milestone:list': handleMilestoneList,
+    'user:get': handleUserGet,
+    'user:list': handleUserList,
+};
+const RESOURCES = (() => {
+    const grouped = {};
+    for (const key of Object.keys(HANDLERS)) {
+        const [resource, action] = key.split(':');
+        if (resource === undefined || action === undefined)
+            continue;
+        const existing = grouped[resource];
+        if (existing === undefined) {
+            grouped[resource] = [action];
+        }
+        else {
+            existing.push(action);
+        }
+    }
+    return grouped;
+})();
+/**
+ * Returns every registered `resource:action` key. Used by the
+ * metadata↔dispatch consistency tests to catch handlers added without a
+ * matching metadata entry — the inverse of the metadata-first check.
+ */
+export function getRegisteredActions() {
+    return Object.keys(HANDLERS);
+}
+export function dispatch(resource, action) {
+    const actions = RESOURCES[resource];
+    if (actions === undefined) {
+        return {
+            ok: false,
+            error: `Unknown resource '${resource}'. Use: ${Object.keys(RESOURCES).join(', ')}`,
+        };
+    }
+    if (!actions.includes(action)) {
+        return {
+            ok: false,
+            error: `Unknown action '${action}' for ${resource}. Use: ${actions.join(', ')}`,
+        };
+    }
+    const handler = HANDLERS[`${resource}:${action}`];
+    if (handler === undefined) {
+        return { ok: false, error: `No handler registered for ${resource}:${action}` };
+    }
+    return { ok: true, handler };
+}
+//# sourceMappingURL=dispatch.js.map

package/dist/cli/handler-context.d.ts

@@ -0,0 +1,43 @@
+import type { TestRailClient } from '../client.js';
+/**
+ * Parsed CLI argument bundle passed to every handler.
+ *
+ * `pathParams` is the slice of positional args after `[resource, action]` —
+ * read handlers consume `pathParams[0]` (the single id), write handlers may
+ * consume multiple (e.g., `result add <run_id> <case_id>` uses [0] and [1]).
+ */
+export interface HandlerArgs {
+    pathParams: readonly string[];
+    projectId?: string;
+    suiteId?: string;
+    runId?: string;
+    caseId?: string;
+    limit?: string;
+    offset?: string;
+}
+/**
+ * Raw inputs for the body-source resolver. The handler decides whether to
+ * consume any of these (write handlers do; read handlers ignore). When all
+ * three are absent for a write action, the resolver emits a "body required"
+ * error.
+ *
+ * `readStdin` is a thunk rather than pre-read contents so stdin is *only*
+ * drained when the resolver actually selects it as the body source. Read
+ * actions and no-body writes (`run close`) never invoke it — avoiding the
+ * "tail -f | testrail run close" hang and the cost of slurping a large
+ * redirected stdin that the handler will throw away.
+ */
+export interface BodyInput {
+    dataFlag?: string;
+    dataFileFlag?: string;
+    readStdin?: () => string;
+}
+export interface HandlerContext {
+    client: TestRailClient;
+    args: HandlerArgs;
+    bodyInput: BodyInput;
+    dryRun: boolean;
+    out: (data: unknown) => void;
+}
+export type Handler = (ctx: HandlerContext) => Promise<void>;
+//# sourceMappingURL=handler-context.d.ts.map

package/dist/cli/handler-context.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=handler-context.js.map

package/dist/cli/handlers/case-write.d.ts

@@ -0,0 +1,4 @@
+import type { HandlerContext } from '../handler-context.js';
+export declare function handleCaseAdd(ctx: HandlerContext): Promise<void>;
+export declare function handleCaseUpdate(ctx: HandlerContext): Promise<void>;
+//# sourceMappingURL=case-write.d.ts.map

package/dist/cli/handlers/case-write.js

@@ -0,0 +1,26 @@
+import { parseId } from '../ids.js';
+import { resolveBody } from '../body.js';
+import { AddCasePayloadSchema, UpdateCasePayloadSchema } from '../../schemas.js';
+export async function handleCaseAdd(ctx) {
+    const sectionId = parseId(ctx.args.pathParams[0], 'section_id');
+    const body = resolveBody(ctx.bodyInput, AddCasePayloadSchema);
+    if (!body.ok)
+        throw new Error(body.error);
+    if (ctx.dryRun) {
+        ctx.out({ dryRun: true, action: 'case add', sectionId, payload: body.payload, source: body.source });
+        return;
+    }
+    ctx.out(await ctx.client.addCase(sectionId, body.payload));
+}
+export async function handleCaseUpdate(ctx) {
+    const caseId = parseId(ctx.args.pathParams[0], 'case_id');
+    const body = resolveBody(ctx.bodyInput, UpdateCasePayloadSchema);
+    if (!body.ok)
+        throw new Error(body.error);
+    if (ctx.dryRun) {
+        ctx.out({ dryRun: true, action: 'case update', caseId, payload: body.payload, source: body.source });
+        return;
+    }
+    ctx.out(await ctx.client.updateCase(caseId, body.payload));
+}
+//# sourceMappingURL=case-write.js.map

package/dist/cli/handlers/case.d.ts

@@ -0,0 +1,4 @@
+import type { HandlerContext } from '../handler-context.js';
+export declare function handleCaseGet(ctx: HandlerContext): Promise<void>;
+export declare function handleCaseList(ctx: HandlerContext): Promise<void>;
+//# sourceMappingURL=case.d.ts.map

package/dist/cli/handlers/case.js

@@ -0,0 +1,11 @@
+import { parseId, optInt } from '../ids.js';
+export async function handleCaseGet(ctx) {
+    const id = parseId(ctx.args.pathParams[0], 'case id');
+    ctx.out(await ctx.client.getCase(id));
+}
+export async function handleCaseList(ctx) {
+    const pid = parseId(ctx.args.projectId, '--project-id');
+    const suiteId = optInt(ctx.args.suiteId);
+    ctx.out(await ctx.client.getCases(pid, suiteId !== undefined ? { suiteId } : undefined));
+}
+//# sourceMappingURL=case.js.map

package/dist/cli/handlers/milestone.d.ts

@@ -0,0 +1,4 @@
+import type { HandlerContext } from '../handler-context.js';
+export declare function handleMilestoneGet(ctx: HandlerContext): Promise<void>;
+export declare function handleMilestoneList(ctx: HandlerContext): Promise<void>;
+//# sourceMappingURL=milestone.d.ts.map

package/dist/cli/handlers/milestone.js

@@ -0,0 +1,15 @@
+import { parseId, optInt } from '../ids.js';
+export async function handleMilestoneGet(ctx) {
+    const id = parseId(ctx.args.pathParams[0], 'milestone id');
+    ctx.out(await ctx.client.getMilestone(id));
+}
+export async function handleMilestoneList(ctx) {
+    const pid = parseId(ctx.args.projectId, '--project-id');
+    const limit = optInt(ctx.args.limit);
+    const offset = optInt(ctx.args.offset);
+    ctx.out(await ctx.client.getMilestones(pid, {
+        ...(limit !== undefined && { limit }),
+        ...(offset !== undefined && { offset }),
+    }));
+}
+//# sourceMappingURL=milestone.js.map

package/dist/cli/handlers/project.d.ts

@@ -0,0 +1,4 @@
+import type { HandlerContext } from '../handler-context.js';
+export declare function handleProjectGet(ctx: HandlerContext): Promise<void>;
+export declare function handleProjectList(ctx: HandlerContext): Promise<void>;
+//# sourceMappingURL=project.d.ts.map

package/dist/cli/handlers/project.js

@@ -0,0 +1,11 @@
+import { parseId, optInt } from '../ids.js';
+export async function handleProjectGet(ctx) {
+    const id = parseId(ctx.args.pathParams[0], 'project id');
+    ctx.out(await ctx.client.getProject(id));
+}
+export async function handleProjectList(ctx) {
+    const limit = optInt(ctx.args.limit);
+    const offset = optInt(ctx.args.offset);
+    ctx.out(await ctx.client.getProjects(limit, offset));
+}
+//# sourceMappingURL=project.js.map

package/dist/cli/handlers/result-write.d.ts

@@ -0,0 +1,4 @@
+import type { HandlerContext } from '../handler-context.js';
+export declare function handleResultAdd(ctx: HandlerContext): Promise<void>;
+export declare function handleResultAddBulk(ctx: HandlerContext): Promise<void>;
+//# sourceMappingURL=result-write.d.ts.map

package/dist/cli/handlers/result-write.js

@@ -0,0 +1,40 @@
+import { parseId } from '../ids.js';
+import { resolveBody } from '../body.js';
+import { AddResultPayloadSchema, AddResultsForCasesPayloadSchema } from '../../schemas.js';
+export async function handleResultAdd(ctx) {
+    const runId = parseId(ctx.args.pathParams[0], 'run_id');
+    const caseId = parseId(ctx.args.pathParams[1], 'case_id');
+    const body = resolveBody(ctx.bodyInput, AddResultPayloadSchema);
+    if (!body.ok)
+        throw new Error(body.error);
+    if (ctx.dryRun) {
+        ctx.out({
+            dryRun: true,
+            action: 'result add',
+            runId,
+            caseId,
+            payload: body.payload,
+            source: body.source,
+        });
+        return;
+    }
+    ctx.out(await ctx.client.addResultForCase(runId, caseId, body.payload));
+}
+export async function handleResultAddBulk(ctx) {
+    const runId = parseId(ctx.args.pathParams[0], 'run_id');
+    const body = resolveBody(ctx.bodyInput, AddResultsForCasesPayloadSchema);
+    if (!body.ok)
+        throw new Error(body.error);
+    if (ctx.dryRun) {
+        ctx.out({
+            dryRun: true,
+            action: 'result add-bulk',
+            runId,
+            payload: body.payload,
+            source: body.source,
+        });
+        return;
+    }
+    ctx.out(await ctx.client.addResultsForCases(runId, body.payload));
+}
+//# sourceMappingURL=result-write.js.map

package/dist/cli/handlers/result.d.ts

@@ -0,0 +1,3 @@
+import type { HandlerContext } from '../handler-context.js';
+export declare function handleResultList(ctx: HandlerContext): Promise<void>;
+//# sourceMappingURL=result.d.ts.map

package/dist/cli/handlers/result.js

@@ -0,0 +1,11 @@
+import { parseId, optInt } from '../ids.js';
+export async function handleResultList(ctx) {
+    const rid = parseId(ctx.args.runId, '--run-id');
+    const limit = optInt(ctx.args.limit);
+    const offset = optInt(ctx.args.offset);
+    ctx.out(await ctx.client.getResultsForRun(rid, {
+        ...(limit !== undefined && { limit }),
+        ...(offset !== undefined && { offset }),
+    }));
+}
+//# sourceMappingURL=result.js.map

package/dist/cli/handlers/run-write.d.ts

@@ -0,0 +1,10 @@
+import type { HandlerContext } from '../handler-context.js';
+export declare function handleRunAdd(ctx: HandlerContext): Promise<void>;
+/**
+ * Close a run. Unlike the other write actions this takes no body — just a
+ * single `run_id` path param. POST has no payload, so the body-source
+ * resolver is not consulted; any `--data` / `--data-file` / stdin supplied
+ * for this action is silently ignored.
+ */
+export declare function handleRunClose(ctx: HandlerContext): Promise<void>;
+//# sourceMappingURL=run-write.d.ts.map

package/dist/cli/handlers/run-write.js

@@ -0,0 +1,29 @@
+import { parseId } from '../ids.js';
+import { resolveBody } from '../body.js';
+import { AddRunPayloadSchema } from '../../schemas.js';
+export async function handleRunAdd(ctx) {
+    const projectId = parseId(ctx.args.pathParams[0], 'project_id');
+    const body = resolveBody(ctx.bodyInput, AddRunPayloadSchema);
+    if (!body.ok)
+        throw new Error(body.error);
+    if (ctx.dryRun) {
+        ctx.out({ dryRun: true, action: 'run add', projectId, payload: body.payload, source: body.source });
+        return;
+    }
+    ctx.out(await ctx.client.addRun(projectId, body.payload));
+}
+/**
+ * Close a run. Unlike the other write actions this takes no body — just a
+ * single `run_id` path param. POST has no payload, so the body-source
+ * resolver is not consulted; any `--data` / `--data-file` / stdin supplied
+ * for this action is silently ignored.
+ */
+export async function handleRunClose(ctx) {
+    const runId = parseId(ctx.args.pathParams[0], 'run_id');
+    if (ctx.dryRun) {
+        ctx.out({ dryRun: true, action: 'run close', runId });
+        return;
+    }
+    ctx.out(await ctx.client.closeRun(runId));
+}
+//# sourceMappingURL=run-write.js.map

package/dist/cli/handlers/run.d.ts

@@ -0,0 +1,4 @@
+import type { HandlerContext } from '../handler-context.js';
+export declare function handleRunGet(ctx: HandlerContext): Promise<void>;
+export declare function handleRunList(ctx: HandlerContext): Promise<void>;
+//# sourceMappingURL=run.d.ts.map

package/dist/cli/handlers/run.js

@@ -0,0 +1,15 @@
+import { parseId, optInt } from '../ids.js';
+export async function handleRunGet(ctx) {
+    const id = parseId(ctx.args.pathParams[0], 'run id');
+    ctx.out(await ctx.client.getRun(id));
+}
+export async function handleRunList(ctx) {
+    const pid = parseId(ctx.args.projectId, '--project-id');
+    const limit = optInt(ctx.args.limit);
+    const offset = optInt(ctx.args.offset);
+    ctx.out(await ctx.client.getRuns(pid, {
+        ...(limit !== undefined && { limit }),
+        ...(offset !== undefined && { offset }),
+    }));
+}
+//# sourceMappingURL=run.js.map

package/dist/cli/handlers/suite.d.ts

@@ -0,0 +1,4 @@
+import type { HandlerContext } from '../handler-context.js';
+export declare function handleSuiteGet(ctx: HandlerContext): Promise<void>;
+export declare function handleSuiteList(ctx: HandlerContext): Promise<void>;
+//# sourceMappingURL=suite.d.ts.map

package/dist/cli/handlers/suite.js

@@ -0,0 +1,10 @@
+import { parseId } from '../ids.js';
+export async function handleSuiteGet(ctx) {
+    const id = parseId(ctx.args.pathParams[0], 'suite id');
+    ctx.out(await ctx.client.getSuite(id));
+}
+export async function handleSuiteList(ctx) {
+    const pid = parseId(ctx.args.projectId, '--project-id');
+    ctx.out(await ctx.client.getSuites(pid));
+}
+//# sourceMappingURL=suite.js.map

package/dist/cli/handlers/user.d.ts

@@ -0,0 +1,4 @@
+import type { HandlerContext } from '../handler-context.js';
+export declare function handleUserGet(ctx: HandlerContext): Promise<void>;
+export declare function handleUserList(ctx: HandlerContext): Promise<void>;
+//# sourceMappingURL=user.d.ts.map

package/dist/cli/handlers/user.js

@@ -0,0 +1,11 @@
+import { parseId, optInt } from '../ids.js';
+export async function handleUserGet(ctx) {
+    const id = parseId(ctx.args.pathParams[0], 'user id');
+    ctx.out(await ctx.client.getUser(id));
+}
+export async function handleUserList(ctx) {
+    const limit = optInt(ctx.args.limit);
+    const offset = optInt(ctx.args.offset);
+    ctx.out(await ctx.client.getUsers(limit, offset));
+}
+//# sourceMappingURL=user.js.map

package/dist/cli/ids.d.ts

@@ -0,0 +1,6 @@
+export declare class IdParseError extends Error {
+    constructor(message: string);
+}
+export declare function parseId(raw: string | undefined, name: string): number;
+export declare function optInt(raw: string | undefined): number | undefined;
+//# sourceMappingURL=ids.d.ts.map

package/dist/cli/ids.js

@@ -0,0 +1,20 @@
+export class IdParseError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'IdParseError';
+    }
+}
+export function parseId(raw, name) {
+    const n = Number(raw);
+    if (raw === undefined || raw === '' || !Number.isInteger(n) || n <= 0) {
+        throw new IdParseError(`${name} must be a positive integer (got: ${raw ?? '(none)'})`);
+    }
+    return n;
+}
+export function optInt(raw) {
+    if (raw === undefined)
+        return undefined;
+    const n = Number(raw);
+    return Number.isInteger(n) && n >= 0 ? n : undefined;
+}
+//# sourceMappingURL=ids.js.map

package/dist/cli/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map