@sapiom/agent-core 0.6.0

package/dist/esm/check.js

@@ -0,0 +1,115 @@
+import { execFileSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { existsSync, mkdtempSync, readFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { assertValidGraph, buildManifest, isAgentDefinition, agentManifestSchema } from '@sapiom/agent';
+import * as esbuild from 'esbuild';
+import { AgentOperationError } from './errors.js';
+function runTypecheck(sourceDir) {
+    const tscBin = path.join(sourceDir, 'node_modules', '.bin', 'tsc');
+    if (!existsSync(tscBin)) {
+        return 'typecheck skipped — TypeScript is not installed (run npm install first)';
+    }
+    try {
+        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 AgentOperationError({
+            code: 'TYPECHECK_FAILED',
+            message: 'The agent has type errors.',
+            hint: output || 'Run `tsc --noEmit` for details.',
+        });
+    }
+}
+const LOCAL_SDK_VERSION = '0.0.0-local';
+export async function check(opts) {
+    const { sourceDir } = opts;
+    const entryFile = path.join(sourceDir, 'index.ts');
+    if (!existsSync(entryFile)) {
+        throw new AgentOperationError({
+            code: 'NO_ENTRY',
+            message: `No index.ts found in ${sourceDir}.`,
+            hint: 'Run this from an agent project, or pass its directory.',
+        });
+    }
+    const warnings = [];
+    const typecheckSkip = runTypecheck(sourceDir);
+    if (typecheckSkip)
+        warnings.push(typecheckSkip);
+    const tmp = mkdtempSync(path.join(tmpdir(), 'sapiom-check-'));
+    const bundlePath = path.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 AgentOperationError({
+                code: 'BUNDLE_FAILED',
+                message: 'Failed to bundle the agent.',
+                hint: err instanceof Error ? err.message : String(err),
+            });
+        }
+        const mod = await import(`file://${bundlePath}?t=${Date.now()}`);
+        const defs = [];
+        for (const value of Object.values(mod)) {
+            if (isAgentDefinition(value) && !defs.includes(value))
+                defs.push(value);
+        }
+        if (defs.length === 0) {
+            throw new AgentOperationError({
+                code: 'NO_DEFINITION',
+                message: 'No agent was exported from index.ts.',
+                hint: 'Export the result of defineAgent({ … }).',
+            });
+        }
+        if (defs.length > 1) {
+            throw new AgentOperationError({
+                code: 'MULTIPLE_DEFINITIONS',
+                message: 'index.ts exports more than one agent.',
+                hint: 'Export exactly one defineAgent({ … }) result.',
+            });
+        }
+        const def = defs[0];
+        const sha256 = createHash('sha256').update(readFileSync(bundlePath)).digest('hex');
+        let manifest;
+        try {
+            manifest = agentManifestSchema.parse(buildManifest(def, { sdkVersion: LOCAL_SDK_VERSION, artifact: { sha256, entryFile: 'definition.mjs' } }));
+        }
+        catch (err) {
+            throw new AgentOperationError({
+                code: 'MANIFEST_INVALID',
+                message: 'The agent produced an invalid manifest.',
+                hint: err instanceof Error ? err.message : String(err),
+            });
+        }
+        try {
+            warnings.push(...assertValidGraph(manifest));
+        }
+        catch (err) {
+            throw new AgentOperationError({
+                code: 'GRAPH_INVALID',
+                message: 'The agent 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 ?? 'agent';
+        return { name, stepCount, warnings, manifest };
+    }
+    finally {
+        rmSync(tmp, { recursive: true, force: true });
+    }
+}

package/dist/esm/client.d.ts

@@ -0,0 +1,21 @@
+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>;
+    openStream(path: string, opts?: {
+        signal?: AbortSignal;
+        lastEventId?: string;
+    }): Promise<Response>;
+}
+export declare function createClient(opts: ClientOptions): GatewayClient;

package/dist/esm/client.js

@@ -0,0 +1,103 @@
+import { AgentOperationError } from './errors.js';
+export const DEFAULT_WORKFLOWS_HOST = 'https://api.sapiom.ai';
+export class GatewayClient {
+    constructor(opts) {
+        const host = (opts.host ?? 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 AgentOperationError({
+                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 AgentOperationError({
+                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 agent.'
+                    : undefined,
+            });
+        }
+        return data;
+    }
+    get(path) {
+        return this.request('GET', path);
+    }
+    post(path, body) {
+        return this.request('POST', path, body);
+    }
+    async openStream(path, opts = {}) {
+        const headers = {
+            'x-api-key': this.apiKey,
+            accept: 'text/event-stream',
+        };
+        if (opts.lastEventId) {
+            headers['last-event-id'] = opts.lastEventId;
+        }
+        let res;
+        try {
+            res = await fetch(`${this.base}${path}`, { method: 'GET', headers, signal: opts.signal });
+        }
+        catch (err) {
+            throw new AgentOperationError({
+                code: 'NETWORK',
+                message: `Could not reach ${this.base}.`,
+                hint: err instanceof Error ? err.message : String(err),
+            });
+        }
+        if (!res.ok) {
+            const text = await res.text().catch(() => '');
+            const data = text ? safeParse(text) : undefined;
+            throw new AgentOperationError({
+                code: `HTTP_${res.status}`,
+                message: messageFrom(data) ?? `Stream 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 agent.'
+                    : undefined,
+            });
+        }
+        if (!res.body) {
+            throw new AgentOperationError({
+                code: 'NETWORK',
+                message: `Stream at ${this.base}${path} returned no body.`,
+            });
+        }
+        return res;
+    }
+}
+export 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/esm/clone.d.ts

@@ -0,0 +1,17 @@
+import { GatewayClient } from './client.js';
+import { type CloneRepoOptions } from './git.js';
+export interface CloneOptions {
+    templateId?: string;
+    forkId?: string;
+    targetDir: string;
+    cloneRepo?: (opts: CloneRepoOptions) => void;
+}
+export interface CloneResult {
+    forkId: string;
+    templateId?: string;
+    repoFullName: string;
+    defaultBranch: string;
+    targetDir: string;
+    tokenExpiresAt: string;
+}
+export declare function clone(opts: CloneOptions, client: GatewayClient): Promise<CloneResult>;

package/dist/esm/clone.js

@@ -0,0 +1,65 @@
+import { existsSync, mkdirSync, readdirSync } from 'node:fs';
+import path from 'node:path';
+import { writeConfig } from './config.js';
+import { AgentOperationError } from './errors.js';
+import { cloneRepo as defaultCloneRepo } from './git.js';
+export async function clone(opts, client) {
+    const { templateId, forkId, targetDir } = opts;
+    const runClone = opts.cloneRepo ?? defaultCloneRepo;
+    if (!templateId && !forkId) {
+        throw new AgentOperationError({
+            code: 'BAD_INPUT',
+            message: 'Provide a templateId (to fork then clone) or a forkId (to clone an existing fork).',
+        });
+    }
+    if (templateId && forkId) {
+        throw new AgentOperationError({
+            code: 'BAD_INPUT',
+            message: 'Provide only one of templateId or forkId, not both.',
+            hint: 'Use templateId to start from a gallery template, or forkId to re-clone an existing fork.',
+        });
+    }
+    if (existsSync(targetDir) && readdirSync(targetDir).length > 0) {
+        throw new AgentOperationError({
+            code: 'DIR_NOT_EMPTY',
+            message: `Target directory '${targetDir}' already exists and is not empty.`,
+        });
+    }
+    let resolvedForkId = forkId ?? '';
+    let resolvedTemplateId = templateId;
+    if (templateId) {
+        const fork = await client.post(`/templates/${encodeURIComponent(templateId)}/fork`, {});
+        resolvedForkId = fork.id;
+        resolvedTemplateId = fork.templateId;
+    }
+    const token = await client.post(`/forks/${encodeURIComponent(resolvedForkId)}/clone-token`, {});
+    if (!token.cloneUrl.startsWith('https://')) {
+        throw new AgentOperationError({
+            code: 'BAD_CLONE_URL',
+            message: 'The clone token endpoint returned an unexpected clone URL.',
+        });
+    }
+    const parent = path.dirname(path.resolve(targetDir));
+    mkdirSync(parent, { recursive: true });
+    runClone({
+        cloneUrl: token.cloneUrl,
+        targetDir,
+        branch: token.defaultBranch,
+        repoFullName: token.repoFullName,
+        cwd: parent,
+    });
+    writeConfig(targetDir, {
+        repoFullName: token.repoFullName,
+        defaultBranch: token.defaultBranch,
+        forkId: resolvedForkId,
+        ...(resolvedTemplateId ? { templateId: resolvedTemplateId } : {}),
+    });
+    return {
+        forkId: resolvedForkId,
+        ...(resolvedTemplateId ? { templateId: resolvedTemplateId } : {}),
+        repoFullName: token.repoFullName,
+        defaultBranch: token.defaultBranch,
+        targetDir,
+        tokenExpiresAt: token.expiresAt,
+    };
+}

package/dist/esm/config.d.ts

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

package/dist/esm/config.js

@@ -0,0 +1,31 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { AgentOperationError } from './errors.js';
+export const CONFIG_FILE = 'sapiom.json';
+export function readConfig(dir) {
+    const file = path.join(dir, CONFIG_FILE);
+    if (!existsSync(file))
+        return null;
+    try {
+        return JSON.parse(readFileSync(file, 'utf8'));
+    }
+    catch {
+        throw new AgentOperationError({ code: 'BAD_CONFIG', message: `${CONFIG_FILE} is not valid JSON.` });
+    }
+}
+export function requireConfig(dir) {
+    const cfg = readConfig(dir);
+    if (!cfg?.definitionId) {
+        throw new AgentOperationError({
+            code: 'NOT_LINKED',
+            message: 'This project is not linked to a Sapiom agent.',
+            hint: 'Run: sapiom agents link <name>',
+        });
+    }
+    return cfg;
+}
+export function writeConfig(dir, cfg) {
+    const existing = readConfig(dir) ?? {};
+    const merged = { ...existing, ...cfg };
+    writeFileSync(path.join(dir, CONFIG_FILE), JSON.stringify(merged, null, 2) + '\n');
+}

package/dist/esm/decode.d.ts

@@ -0,0 +1,4 @@
+import type { CostNode, ExecutionProjection, ExecutionRef } from "./types.js";
+export declare function decodeCostNode(raw: unknown): CostNode | null;
+export declare function decodeExecutionRef(raw: unknown): ExecutionRef;
+export declare function decodeExecutionProjection(raw: unknown): ExecutionProjection;

package/dist/esm/decode.js

@@ -0,0 +1,167 @@
+function isRecord(v) {
+    return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function rec(v) {
+    return isRecord(v) ? v : {};
+}
+function str(fallback, ...candidates) {
+    for (const c of candidates)
+        if (typeof c === "string")
+            return c;
+    return fallback;
+}
+function strOrNull(...candidates) {
+    for (const c of candidates)
+        if (typeof c === "string")
+            return c;
+    return null;
+}
+function numOr(fallback, v) {
+    return typeof v === "number" && Number.isFinite(v) ? v : fallback;
+}
+function recordOrNull(v) {
+    return isRecord(v) ? v : null;
+}
+const SETTLE_STATES = ["pending", "settling", "final"];
+function settleState(v) {
+    return typeof v === "string" && SETTLE_STATES.includes(v)
+        ? v
+        : "final";
+}
+export function decodeCostNode(raw) {
+    if (!isRecord(raw))
+        return null;
+    return {
+        authorizedUsd: str("0", raw.authorizedUsd),
+        capturedUsd: str("0", raw.capturedUsd),
+        settleState: settleState(raw.settleState),
+    };
+}
+function decodeStepErrorFrame(raw) {
+    const r = rec(raw);
+    const frame = {};
+    if (typeof r.function === "string")
+        frame.function = r.function;
+    if (typeof r.file === "string")
+        frame.file = r.file;
+    if (typeof r.line === "number")
+        frame.line = r.line;
+    if (typeof r.column === "number")
+        frame.column = r.column;
+    return frame;
+}
+function decodeStepErrorTrace(raw) {
+    if (typeof raw === "string") {
+        return { frames: [], sourceMapped: false, raw };
+    }
+    if (!isRecord(raw))
+        return null;
+    const trace = {
+        frames: Array.isArray(raw.frames) ? raw.frames.map(decodeStepErrorFrame) : [],
+        sourceMapped: raw.sourceMapped === true,
+    };
+    if (typeof raw.raw === "string")
+        trace.raw = raw.raw;
+    return trace;
+}
+function decodeStepError(raw) {
+    if (!isRecord(raw))
+        return null;
+    const message = strOrNull(raw.message);
+    if (message === null)
+        return null;
+    return {
+        message,
+        trace: decodeStepErrorTrace(raw.trace ?? raw.stack ?? null),
+        traceUnavailableReason: strOrNull(raw.traceUnavailableReason),
+    };
+}
+function decodeStepEvent(raw) {
+    const r = rec(raw);
+    return {
+        sourceId: str("", r.sourceId),
+        sequence: numOr(0, r.sequence),
+        kind: str("", r.kind),
+        payload: recordOrNull(r.payload) ?? {},
+        eventTs: strOrNull(r.eventTs),
+    };
+}
+function decodeDispatchRef(raw) {
+    if (!isRecord(raw))
+        return null;
+    return {
+        childExecutionId: str("", raw.childExecutionId, raw.targetId, raw.executionId),
+        targetType: str("", raw.targetType),
+        correlationId: str("", raw.correlationId),
+        status: str("", raw.status),
+    };
+}
+export function decodeExecutionRef(raw) {
+    const r = rec(raw);
+    const executionId = str("", r.executionId, r.id);
+    return {
+        executionId,
+        traceRoot: str(executionId, r.traceRoot, r.rootExecutionId),
+        name: str("", r.name),
+        status: str("", r.status),
+    };
+}
+function decodeStep(raw) {
+    const r = rec(raw);
+    return {
+        stepName: str("", r.stepName),
+        stepOrder: numOr(0, r.stepOrder),
+        attempt: numOr(0, r.attempt),
+        status: str("", r.status),
+        spanId: strOrNull(r.spanId),
+        startedAt: strOrNull(r.startedAt),
+        finishedAt: strOrNull(r.finishedAt),
+        input: r.input ?? null,
+        output: r.output ?? null,
+        sharedStateAfter: recordOrNull(r.sharedStateAfter),
+        nextDirective: r.nextDirective ?? null,
+        cost: decodeCostNode(r.cost),
+        logs: r.logs ?? null,
+        events: Array.isArray(r.events) ? r.events.map(decodeStepEvent) : [],
+        error: decodeStepError(r.error),
+        dispatch: decodeDispatchRef(r.dispatch),
+    };
+}
+export function decodeExecutionProjection(raw) {
+    const r = rec(raw);
+    const id = str("", r.id, r.executionId);
+    const traceRoot = str(id, r.traceRoot, r.rootExecutionId);
+    const traceParent = strOrNull(r.traceParent, r.parentExecutionId);
+    return {
+        id,
+        name: str("", r.name),
+        organizationId: strOrNull(r.organizationId),
+        tenantId: strOrNull(r.tenantId),
+        status: str("", r.status),
+        currentStep: strOrNull(r.currentStep),
+        currentStepAttempt: numOr(0, r.currentStepAttempt),
+        version: numOr(0, r.version),
+        definitionId: strOrNull(r.definitionId),
+        buildRunId: strOrNull(r.buildRunId),
+        idempotencyKey: strOrNull(r.idempotencyKey),
+        pausedSignalName: strOrNull(r.pausedSignalName),
+        pausedSignalCorrelationId: strOrNull(r.pausedSignalCorrelationId),
+        pausedUntil: strOrNull(r.pausedUntil),
+        startedAt: str("", r.startedAt),
+        finishedAt: strOrNull(r.finishedAt),
+        input: r.input ?? null,
+        sharedState: recordOrNull(r.sharedState) ?? {},
+        output: r.output ?? null,
+        error: r.error ?? null,
+        pausedStepInputSchema: recordOrNull(r.pausedStepInputSchema),
+        pausedStepInputExample: r.pausedStepInputExample ?? null,
+        traceRoot,
+        rootExecutionId: str(traceRoot, r.rootExecutionId, r.traceRoot),
+        traceParent,
+        parentExecutionId: strOrNull(r.parentExecutionId, r.traceParent),
+        traceId: strOrNull(r.traceId),
+        children: Array.isArray(r.children) ? r.children.map(decodeExecutionRef) : [],
+        cost: decodeCostNode(r.cost),
+        steps: Array.isArray(r.steps) ? r.steps.map(decodeStep) : [],
+    };
+}

package/dist/esm/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/esm/deploy.js

@@ -0,0 +1,61 @@
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { bundleForDeploy } from './bundle.js';
+import { AgentOperationError } from './errors.js';
+import { assertDeployable, pushSynthesizedTree } from './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));
+export async function deploy(opts, client) {
+    const { projectDir, definitionId, branch = 'main' } = opts;
+    assertDeployable(projectDir);
+    const { code, dependencies } = await bundleForDeploy(projectDir);
+    const { pushUrl } = await client.post(`/definitions/${definitionId}/push-credentials`, {});
+    const treeDir = mkdtempSync(path.join(tmpdir(), 'sapiom-deploy-'));
+    try {
+        writeFileSync(path.join(treeDir, 'index.ts'), code);
+        writeFileSync(path.join(treeDir, 'package.json'), JSON.stringify({ name: 'agent-definition', private: true, type: 'module', dependencies }, null, 2) + '\n');
+        pushSynthesizedTree(treeDir, pushUrl, branch);
+    }
+    finally {
+        rmSync(treeDir, { recursive: true, force: true });
+    }
+    const triggered = await client.post(`/definitions/${definitionId}/builds`, {});
+    const buildRunId = triggered.buildRunId ?? triggered.id;
+    if (!buildRunId) {
+        throw new AgentOperationError({
+            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 AgentOperationError({
+            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 AgentOperationError({
+        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/esm/errors.d.ts

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

package/dist/esm/errors.js

@@ -0,0 +1,19 @@
+export class AgentOperationError extends Error {
+    constructor(err) {
+        super(err.message);
+        this.name = 'AgentOperationError';
+        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 } : {}),
+        };
+    }
+}

package/dist/esm/git.d.ts

@@ -0,0 +1,12 @@
+export declare function assertDeployable(dir: string): void;
+export declare function redactCredentials(text: string): string;
+export interface CloneRepoOptions {
+    cloneUrl: string;
+    targetDir: string;
+    branch: string;
+    repoFullName: string;
+    cwd: string;
+}
+export declare function cloneRepo(opts: CloneRepoOptions): void;
+export declare function pushHead(dir: string, pushUrl: string, branch: string): void;
+export declare function pushSynthesizedTree(treeDir: string, pushUrl: string, branch: string): void;