@sapiom/orchestration-core 0.1.1

package/CHANGELOG.md

@@ -0,0 +1,9 @@
+# @sapiom/orchestration-core
+
+## 0.1.1
+
+### Patch Changes
+
+- Updated dependencies [7f6859e]
+  - @sapiom/tools@0.2.0
+  - @sapiom/orchestration@0.1.6

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Sapiom
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/cjs/check.d.ts

@@ -0,0 +1,10 @@
+export interface CheckOptions {
+    sourceDir: string;
+}
+export interface CheckResult {
+    name: string;
+    stepCount: number;
+    warnings: string[];
+    manifest: unknown;
+}
+export declare function check(opts: CheckOptions): Promise<CheckResult>;

package/dist/cjs/check.js

@@ -0,0 +1,154 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.check = check;
+const node_child_process_1 = require("node:child_process");
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = __importDefault(require("node:path"));
+const orchestration_1 = require("@sapiom/orchestration");
+const esbuild = __importStar(require("esbuild"));
+const errors_js_1 = require("./errors.js");
+function runTypecheck(sourceDir) {
+    const tscBin = node_path_1.default.join(sourceDir, 'node_modules', '.bin', 'tsc');
+    if (!(0, node_fs_1.existsSync)(tscBin)) {
+        return 'typecheck skipped — TypeScript is not installed (run npm install first)';
+    }
+    try {
+        (0, node_child_process_1.execFileSync)(tscBin, ['--noEmit'], { cwd: sourceDir, stdio: ['ignore', 'pipe', 'pipe'] });
+        return null;
+    }
+    catch (err) {
+        const e = err;
+        const output = (e.stdout?.toString() ?? '').trim() || (e.stderr?.toString() ?? '').trim();
+        throw new errors_js_1.OrchestrationError({
+            code: 'TYPECHECK_FAILED',
+            message: 'The orchestration has type errors.',
+            hint: output || 'Run `tsc --noEmit` for details.',
+        });
+    }
+}
+const LOCAL_SDK_VERSION = '0.0.0-local';
+async function check(opts) {
+    const { sourceDir } = opts;
+    const entryFile = node_path_1.default.join(sourceDir, 'index.ts');
+    if (!(0, node_fs_1.existsSync)(entryFile)) {
+        throw new errors_js_1.OrchestrationError({
+            code: 'NO_ENTRY',
+            message: `No index.ts found in ${sourceDir}.`,
+            hint: 'Run this from an orchestration project, or pass its directory.',
+        });
+    }
+    const warnings = [];
+    const typecheckSkip = runTypecheck(sourceDir);
+    if (typecheckSkip)
+        warnings.push(typecheckSkip);
+    const tmp = (0, node_fs_1.mkdtempSync)(node_path_1.default.join((0, node_os_1.tmpdir)(), 'sapiom-check-'));
+    const bundlePath = node_path_1.default.join(tmp, 'definition.mjs');
+    try {
+        try {
+            await esbuild.build({
+                entryPoints: [entryFile],
+                outfile: bundlePath,
+                bundle: true,
+                platform: 'node',
+                target: 'node20',
+                format: 'esm',
+                logLevel: 'silent',
+            });
+        }
+        catch (err) {
+            throw new errors_js_1.OrchestrationError({
+                code: 'BUNDLE_FAILED',
+                message: 'Failed to bundle the orchestration.',
+                hint: err instanceof Error ? err.message : String(err),
+            });
+        }
+        const mod = await Promise.resolve(`${`file://${bundlePath}?t=${Date.now()}`}`).then(s => __importStar(require(s)));
+        const defs = [];
+        for (const value of Object.values(mod)) {
+            if ((0, orchestration_1.isOrchestrationDefinition)(value) && !defs.includes(value))
+                defs.push(value);
+        }
+        if (defs.length === 0) {
+            throw new errors_js_1.OrchestrationError({
+                code: 'NO_DEFINITION',
+                message: 'No orchestration was exported from index.ts.',
+                hint: 'Export the result of defineOrchestration({ … }).',
+            });
+        }
+        if (defs.length > 1) {
+            throw new errors_js_1.OrchestrationError({
+                code: 'MULTIPLE_DEFINITIONS',
+                message: 'index.ts exports more than one orchestration.',
+                hint: 'Export exactly one defineOrchestration({ … }) result.',
+            });
+        }
+        const def = defs[0];
+        const sha256 = (0, node_crypto_1.createHash)('sha256').update((0, node_fs_1.readFileSync)(bundlePath)).digest('hex');
+        let manifest;
+        try {
+            manifest = orchestration_1.workflowManifestSchema.parse((0, orchestration_1.buildManifest)(def, { sdkVersion: LOCAL_SDK_VERSION, artifact: { sha256, entryFile: 'definition.mjs' } }));
+        }
+        catch (err) {
+            throw new errors_js_1.OrchestrationError({
+                code: 'MANIFEST_INVALID',
+                message: 'The orchestration produced an invalid manifest.',
+                hint: err instanceof Error ? err.message : String(err),
+            });
+        }
+        try {
+            warnings.push(...(0, orchestration_1.assertValidGraph)(manifest));
+        }
+        catch (err) {
+            throw new errors_js_1.OrchestrationError({
+                code: 'GRAPH_INVALID',
+                message: 'The orchestration graph is invalid.',
+                hint: err instanceof Error ? err.message : String(err),
+            });
+        }
+        const steps = manifest.steps;
+        const stepCount = Array.isArray(steps) ? steps.length : Object.keys(steps ?? {}).length;
+        const name = manifest.name ?? 'orchestration';
+        return { name, stepCount, warnings, manifest };
+    }
+    finally {
+        (0, node_fs_1.rmSync)(tmp, { recursive: true, force: true });
+    }
+}

package/dist/cjs/client.d.ts

@@ -0,0 +1,17 @@
+export declare const DEFAULT_WORKFLOWS_HOST = "https://api.sapiom.ai";
+export interface ClientOptions {
+    host?: string;
+    apiKey: string;
+}
+export interface GatewayErrorBody {
+    message?: string | string[];
+}
+export declare class GatewayClient {
+    private readonly base;
+    private readonly apiKey;
+    constructor(opts: ClientOptions);
+    request<T = unknown>(method: string, path: string, body?: unknown): Promise<T>;
+    get<T = unknown>(path: string): Promise<T>;
+    post<T = unknown>(path: string, body?: unknown): Promise<T>;
+}
+export declare function createClient(opts: ClientOptions): GatewayClient;

package/dist/cjs/client.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GatewayClient = exports.DEFAULT_WORKFLOWS_HOST = void 0;
+exports.createClient = createClient;
+const errors_js_1 = require("./errors.js");
+exports.DEFAULT_WORKFLOWS_HOST = 'https://api.sapiom.ai';
+class GatewayClient {
+    constructor(opts) {
+        const host = (opts.host ?? exports.DEFAULT_WORKFLOWS_HOST).replace(/\/$/, '');
+        this.base = `${host}/v1/workflows`;
+        this.apiKey = opts.apiKey;
+    }
+    async request(method, path, body) {
+        let res;
+        try {
+            res = await fetch(`${this.base}${path}`, {
+                method,
+                headers: { 'x-api-key': this.apiKey, 'content-type': 'application/json' },
+                body: body === undefined ? undefined : JSON.stringify(body),
+            });
+        }
+        catch (err) {
+            throw new errors_js_1.OrchestrationError({
+                code: 'NETWORK',
+                message: `Could not reach ${this.base}.`,
+                hint: err instanceof Error ? err.message : String(err),
+            });
+        }
+        const text = await res.text();
+        const data = text ? safeParse(text) : undefined;
+        if (!res.ok) {
+            throw new errors_js_1.OrchestrationError({
+                code: `HTTP_${res.status}`,
+                message: messageFrom(data) ?? `Request failed (${res.status} ${res.statusText}).`,
+                hint: res.status === 401 || res.status === 403
+                    ? 'Check your API key (`sapiom login` or SAPIOM_API_KEY) and that it has access to this orchestration.'
+                    : undefined,
+            });
+        }
+        return data;
+    }
+    get(path) {
+        return this.request('GET', path);
+    }
+    post(path, body) {
+        return this.request('POST', path, body);
+    }
+}
+exports.GatewayClient = GatewayClient;
+function createClient(opts) {
+    return new GatewayClient(opts);
+}
+function safeParse(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+function messageFrom(data) {
+    if (data && typeof data === 'object' && 'message' in data) {
+        const m = data.message;
+        if (Array.isArray(m))
+            return m.join('; ');
+        if (typeof m === 'string')
+            return m;
+    }
+    return undefined;
+}

package/dist/cjs/config.d.ts

@@ -0,0 +1,9 @@
+export declare const CONFIG_FILE = "sapiom.json";
+export interface SapiomConfig {
+    definitionId: string;
+    name: string;
+    host?: string;
+}
+export declare function readConfig(dir: string): SapiomConfig | null;
+export declare function requireConfig(dir: string): SapiomConfig;
+export declare function writeConfig(dir: string, cfg: SapiomConfig): void;

package/dist/cjs/config.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONFIG_FILE = void 0;
+exports.readConfig = readConfig;
+exports.requireConfig = requireConfig;
+exports.writeConfig = writeConfig;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const errors_js_1 = require("./errors.js");
+exports.CONFIG_FILE = 'sapiom.json';
+function readConfig(dir) {
+    const file = node_path_1.default.join(dir, exports.CONFIG_FILE);
+    if (!(0, node_fs_1.existsSync)(file))
+        return null;
+    try {
+        return JSON.parse((0, node_fs_1.readFileSync)(file, 'utf8'));
+    }
+    catch {
+        throw new errors_js_1.OrchestrationError({ code: 'BAD_CONFIG', message: `${exports.CONFIG_FILE} is not valid JSON.` });
+    }
+}
+function requireConfig(dir) {
+    const cfg = readConfig(dir);
+    if (!cfg?.definitionId) {
+        throw new errors_js_1.OrchestrationError({
+            code: 'NOT_LINKED',
+            message: 'This project is not linked to a Sapiom orchestration.',
+            hint: 'Run: sapiom orchestrations link <name>',
+        });
+    }
+    return cfg;
+}
+function writeConfig(dir, cfg) {
+    (0, node_fs_1.writeFileSync)(node_path_1.default.join(dir, exports.CONFIG_FILE), JSON.stringify(cfg, null, 2) + '\n');
+}

package/dist/cjs/deploy.d.ts

@@ -0,0 +1,12 @@
+import { GatewayClient } from './client.js';
+export interface DeployOptions {
+    projectDir: string;
+    definitionId: string;
+    branch?: string;
+}
+export interface DeployResult {
+    definitionId: string;
+    buildRunId: string;
+    status: string;
+}
+export declare function deploy(opts: DeployOptions, client: GatewayClient): Promise<DeployResult>;

package/dist/cjs/deploy.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deploy = deploy;
+const errors_js_1 = require("./errors.js");
+const git_js_1 = require("./git.js");
+const TERMINAL = new Set(['ready', 'failed', 'cancelled', 'superseded']);
+const POLL_DELAYS_MS = [1000, 2000, 3000, 5000, 5000, 8000, 10000];
+const POLL_BUDGET_MS = 300000;
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function deploy(opts, client) {
+    const { projectDir, definitionId, branch = 'main' } = opts;
+    (0, git_js_1.assertDeployable)(projectDir);
+    const { pushUrl } = await client.post(`/definitions/${definitionId}/push-credentials`, {});
+    (0, git_js_1.pushHead)(projectDir, pushUrl, branch);
+    const triggered = await client.post(`/definitions/${definitionId}/builds`, {});
+    const buildRunId = triggered.buildRunId ?? triggered.id;
+    if (!buildRunId) {
+        throw new errors_js_1.OrchestrationError({
+            code: 'BUILD_NO_ID',
+            message: 'The build was triggered but no build id was returned.',
+        });
+    }
+    const final = await pollBuild(client, definitionId, buildRunId);
+    if (final.status !== 'ready') {
+        throw new errors_js_1.OrchestrationError({
+            code: 'BUILD_FAILED',
+            message: `Build ${final.status}.`,
+            step: 'build',
+            hint: final.error?.stack || final.error?.message,
+        });
+    }
+    return { definitionId, buildRunId, status: final.status };
+}
+async function pollBuild(client, definitionId, buildRunId) {
+    let elapsed = 0;
+    let i = 0;
+    while (elapsed < POLL_BUDGET_MS) {
+        const build = await client.get(`/definitions/${definitionId}/builds/${buildRunId}`);
+        if (TERMINAL.has(build.status))
+            return build;
+        const delay = POLL_DELAYS_MS[Math.min(i++, POLL_DELAYS_MS.length - 1)];
+        await sleep(delay);
+        elapsed += delay;
+    }
+    throw new errors_js_1.OrchestrationError({
+        code: 'BUILD_TIMEOUT',
+        message: 'Build did not finish in time.',
+        step: 'build',
+        hint: `Check it later via the logs API for build ${buildRunId}`,
+    });
+}

package/dist/cjs/errors.d.ts

@@ -0,0 +1,15 @@
+export interface StructuredError {
+    code: string;
+    message: string;
+    step?: string;
+    hint?: string;
+    docsUrl?: string;
+}
+export declare class OrchestrationError extends Error {
+    readonly code: string;
+    readonly step?: string;
+    readonly hint?: string;
+    readonly docsUrl?: string;
+    constructor(err: StructuredError);
+    toStructured(): StructuredError;
+}

package/dist/cjs/errors.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrchestrationError = void 0;
+class OrchestrationError extends Error {
+    constructor(err) {
+        super(err.message);
+        this.name = 'OrchestrationError';
+        this.code = err.code;
+        this.step = err.step;
+        this.hint = err.hint;
+        this.docsUrl = err.docsUrl;
+    }
+    toStructured() {
+        return {
+            code: this.code,
+            message: this.message,
+            ...(this.step ? { step: this.step } : {}),
+            ...(this.hint ? { hint: this.hint } : {}),
+            ...(this.docsUrl ? { docsUrl: this.docsUrl } : {}),
+        };
+    }
+}
+exports.OrchestrationError = OrchestrationError;

package/dist/cjs/git.d.ts

@@ -0,0 +1,2 @@
+export declare function assertDeployable(dir: string): void;
+export declare function pushHead(dir: string, pushUrl: string, branch: string): void;

package/dist/cjs/git.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertDeployable = assertDeployable;
+exports.pushHead = pushHead;
+const node_child_process_1 = require("node:child_process");
+const errors_js_1 = require("./errors.js");
+function git(args, cwd) {
+    try {
+        return (0, node_child_process_1.execFileSync)('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }).trim();
+    }
+    catch (err) {
+        const stderr = err.stderr?.toString().trim();
+        throw new errors_js_1.OrchestrationError({
+            code: 'GIT',
+            message: `git ${args[0]} failed.`,
+            hint: stderr || (err instanceof Error ? err.message : String(err)),
+        });
+    }
+}
+function assertDeployable(dir) {
+    try {
+        (0, node_child_process_1.execFileSync)('git', ['rev-parse', '--is-inside-work-tree'], { cwd: dir, stdio: 'ignore' });
+    }
+    catch {
+        throw new errors_js_1.OrchestrationError({
+            code: 'NOT_GIT',
+            message: 'Not a git repository.',
+            hint: 'Initialize one: git init && git add -A && git commit -m "init"',
+        });
+    }
+    try {
+        (0, node_child_process_1.execFileSync)('git', ['rev-parse', 'HEAD'], { cwd: dir, stdio: 'ignore' });
+    }
+    catch {
+        throw new errors_js_1.OrchestrationError({
+            code: 'NO_COMMITS',
+            message: 'This repository has no commits yet.',
+            hint: 'Commit your work: git add -A && git commit -m "…"',
+        });
+    }
+}
+function pushHead(dir, pushUrl, branch) {
+    git(['push', '--force', pushUrl, `HEAD:${branch}`], dir);
+}

package/dist/cjs/index.d.ts

@@ -0,0 +1,29 @@
+export { OrchestrationError } from './errors.js';
+export type { StructuredError } from './errors.js';
+export { GatewayClient, createClient, DEFAULT_WORKFLOWS_HOST } from './client.js';
+export type { ClientOptions, GatewayErrorBody } from './client.js';
+export { readConfig, requireConfig, writeConfig, CONFIG_FILE } from './config.js';
+export type { SapiomConfig } from './config.js';
+export { scaffold, resolveVersions, resolveTemplate, listTemplates, DEFAULT_TEMPLATE } from './scaffold.js';
+export type { ScaffoldOptions, ScaffoldResult, ResolvedVersions } from './scaffold.js';
+export { check } from './check.js';
+export type { CheckOptions, CheckResult } from './check.js';
+export { link } from './link.js';
+export type { LinkOptions, LinkResult, DefinitionSummary } from './link.js';
+export { deploy } from './deploy.js';
+export type { DeployOptions, DeployResult } from './deploy.js';
+export { run, parseJsonInput } from './run.js';
+export type { RunOptions, RunResult } from './run.js';
+export { inspect, listExecutions, inspectBuild } from './inspect.js';
+export type { InspectOptions, InspectResult, ListExecutionsResult, InspectBuildOptions, InspectBuildResult, ExecutionDetail, StepRecord, BuildDetail, } from './inspect.js';
+export { signal, parseSignalPayload } from './signal.js';
+export type { SignalOptions, SignalResult } from './signal.js';
+export { assertDeployable, pushHead } from './git.js';
+export { parseStubFile, STUB_FILE_VERSION } from './local/stubs.js';
+export type { StubFile, StepStubs, StubResponse } from './local/stubs.js';
+export { runLocal, runLocalFromDir, STUBS_FILE } from './local/run-local.js';
+export type { RunLocalOptions, LocalRunResult, LocalRunOutcome } from './local/run-local.js';
+export { loadDefinition } from './local/load.js';
+export type { LoadedDefinition } from './local/load.js';
+export { LocalStubDispatcher } from './local/dispatcher.js';
+export type { LocalStepTrace, LogEntry } from './local/dispatcher.js';

package/dist/cjs/index.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalStubDispatcher = exports.loadDefinition = exports.STUBS_FILE = exports.runLocalFromDir = exports.runLocal = exports.STUB_FILE_VERSION = exports.parseStubFile = exports.pushHead = exports.assertDeployable = exports.parseSignalPayload = exports.signal = exports.inspectBuild = exports.listExecutions = exports.inspect = exports.parseJsonInput = exports.run = exports.deploy = exports.link = exports.check = exports.DEFAULT_TEMPLATE = exports.listTemplates = exports.resolveTemplate = exports.resolveVersions = exports.scaffold = exports.CONFIG_FILE = exports.writeConfig = exports.requireConfig = exports.readConfig = exports.DEFAULT_WORKFLOWS_HOST = exports.createClient = exports.GatewayClient = exports.OrchestrationError = void 0;
+var errors_js_1 = require("./errors.js");
+Object.defineProperty(exports, "OrchestrationError", { enumerable: true, get: function () { return errors_js_1.OrchestrationError; } });
+var client_js_1 = require("./client.js");
+Object.defineProperty(exports, "GatewayClient", { enumerable: true, get: function () { return client_js_1.GatewayClient; } });
+Object.defineProperty(exports, "createClient", { enumerable: true, get: function () { return client_js_1.createClient; } });
+Object.defineProperty(exports, "DEFAULT_WORKFLOWS_HOST", { enumerable: true, get: function () { return client_js_1.DEFAULT_WORKFLOWS_HOST; } });
+var config_js_1 = require("./config.js");
+Object.defineProperty(exports, "readConfig", { enumerable: true, get: function () { return config_js_1.readConfig; } });
+Object.defineProperty(exports, "requireConfig", { enumerable: true, get: function () { return config_js_1.requireConfig; } });
+Object.defineProperty(exports, "writeConfig", { enumerable: true, get: function () { return config_js_1.writeConfig; } });
+Object.defineProperty(exports, "CONFIG_FILE", { enumerable: true, get: function () { return config_js_1.CONFIG_FILE; } });
+var scaffold_js_1 = require("./scaffold.js");
+Object.defineProperty(exports, "scaffold", { enumerable: true, get: function () { return scaffold_js_1.scaffold; } });
+Object.defineProperty(exports, "resolveVersions", { enumerable: true, get: function () { return scaffold_js_1.resolveVersions; } });
+Object.defineProperty(exports, "resolveTemplate", { enumerable: true, get: function () { return scaffold_js_1.resolveTemplate; } });
+Object.defineProperty(exports, "listTemplates", { enumerable: true, get: function () { return scaffold_js_1.listTemplates; } });
+Object.defineProperty(exports, "DEFAULT_TEMPLATE", { enumerable: true, get: function () { return scaffold_js_1.DEFAULT_TEMPLATE; } });
+var check_js_1 = require("./check.js");
+Object.defineProperty(exports, "check", { enumerable: true, get: function () { return check_js_1.check; } });
+var link_js_1 = require("./link.js");
+Object.defineProperty(exports, "link", { enumerable: true, get: function () { return link_js_1.link; } });
+var deploy_js_1 = require("./deploy.js");
+Object.defineProperty(exports, "deploy", { enumerable: true, get: function () { return deploy_js_1.deploy; } });
+var run_js_1 = require("./run.js");
+Object.defineProperty(exports, "run", { enumerable: true, get: function () { return run_js_1.run; } });
+Object.defineProperty(exports, "parseJsonInput", { enumerable: true, get: function () { return run_js_1.parseJsonInput; } });
+var inspect_js_1 = require("./inspect.js");
+Object.defineProperty(exports, "inspect", { enumerable: true, get: function () { return inspect_js_1.inspect; } });
+Object.defineProperty(exports, "listExecutions", { enumerable: true, get: function () { return inspect_js_1.listExecutions; } });
+Object.defineProperty(exports, "inspectBuild", { enumerable: true, get: function () { return inspect_js_1.inspectBuild; } });
+var signal_js_1 = require("./signal.js");
+Object.defineProperty(exports, "signal", { enumerable: true, get: function () { return signal_js_1.signal; } });
+Object.defineProperty(exports, "parseSignalPayload", { enumerable: true, get: function () { return signal_js_1.parseSignalPayload; } });
+var git_js_1 = require("./git.js");
+Object.defineProperty(exports, "assertDeployable", { enumerable: true, get: function () { return git_js_1.assertDeployable; } });
+Object.defineProperty(exports, "pushHead", { enumerable: true, get: function () { return git_js_1.pushHead; } });
+var stubs_js_1 = require("./local/stubs.js");
+Object.defineProperty(exports, "parseStubFile", { enumerable: true, get: function () { return stubs_js_1.parseStubFile; } });
+Object.defineProperty(exports, "STUB_FILE_VERSION", { enumerable: true, get: function () { return stubs_js_1.STUB_FILE_VERSION; } });
+var run_local_js_1 = require("./local/run-local.js");
+Object.defineProperty(exports, "runLocal", { enumerable: true, get: function () { return run_local_js_1.runLocal; } });
+Object.defineProperty(exports, "runLocalFromDir", { enumerable: true, get: function () { return run_local_js_1.runLocalFromDir; } });
+Object.defineProperty(exports, "STUBS_FILE", { enumerable: true, get: function () { return run_local_js_1.STUBS_FILE; } });
+var load_js_1 = require("./local/load.js");
+Object.defineProperty(exports, "loadDefinition", { enumerable: true, get: function () { return load_js_1.loadDefinition; } });
+var dispatcher_js_1 = require("./local/dispatcher.js");
+Object.defineProperty(exports, "LocalStubDispatcher", { enumerable: true, get: function () { return dispatcher_js_1.LocalStubDispatcher; } });

package/dist/cjs/inspect.d.ts

@@ -0,0 +1,41 @@
+import { GatewayClient } from './client.js';
+export interface StepRecord {
+    stepName: string;
+    attempt: number;
+    status: string;
+    error?: {
+        message?: string;
+        stack?: string;
+    } | null;
+}
+export interface ExecutionDetail {
+    id: string;
+    status: string;
+    currentStep?: string | null;
+    error?: unknown;
+    steps?: StepRecord[];
+}
+export interface BuildDetail {
+    id?: string;
+    status: string;
+    error?: unknown;
+}
+export interface InspectOptions {
+    executionId: string;
+}
+export interface InspectResult {
+    execution: ExecutionDetail;
+}
+export declare function inspect(opts: InspectOptions, client: GatewayClient): Promise<InspectResult>;
+export interface ListExecutionsResult {
+    executions: ExecutionDetail[];
+}
+export declare function listExecutions(client: GatewayClient): Promise<ListExecutionsResult>;
+export interface InspectBuildOptions {
+    definitionId: string;
+    buildRunId: string;
+}
+export interface InspectBuildResult {
+    build: BuildDetail;
+}
+export declare function inspectBuild(opts: InspectBuildOptions, client: GatewayClient): Promise<InspectBuildResult>;

package/dist/cjs/inspect.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inspect = inspect;
+exports.listExecutions = listExecutions;
+exports.inspectBuild = inspectBuild;
+async function inspect(opts, client) {
+    const execution = await client.get(`/executions/${opts.executionId}`);
+    return { execution };
+}
+async function listExecutions(client) {
+    const executions = await client.get('/executions');
+    return { executions };
+}
+async function inspectBuild(opts, client) {
+    const build = await client.get(`/definitions/${opts.definitionId}/builds/${opts.buildRunId}`);
+    return { build };
+}

package/dist/cjs/link.d.ts

@@ -0,0 +1,15 @@
+import { GatewayClient } from './client.js';
+export interface DefinitionSummary {
+    id: string;
+    name: string;
+    slug?: string;
+}
+export interface LinkOptions {
+    name: string;
+    create?: boolean;
+}
+export interface LinkResult {
+    definitionId: string;
+    name: string;
+}
+export declare function link(opts: LinkOptions, client: GatewayClient): Promise<LinkResult>;