@devramps/sdk-typescript 0.1.0

package/dist/base/polling-step.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PollingStep = void 0;
+const base_step_1 = require("./base-step");
+/**
+ * A polling step for long-running operations that need status checks.
+ *
+ * Users extend this class and implement:
+ * - `trigger(params)` - Start the operation, return initial polling state
+ * - `poll(params, pollingState)` - Check status, return POLL_AGAIN, SUCCESS, or FAILED
+ *
+ * Optionally override `prepare` to require approval before triggering.
+ *
+ * @typeParam TParams - The input parameters type (validated by schema)
+ * @typeParam TPollingState - The polling state type passed between poll calls
+ *
+ * @example
+ * ```typescript
+ * type JobParams = { target: string };
+ * type JobPollingState = { jobId: string; startedAt: number };
+ *
+ * @Step({ name: "Long Job", type: "long-job", schema: jobSchema })
+ * class LongJobStep extends PollingStep<JobParams, JobPollingState> {
+ *   async trigger(params: JobParams): Promise<TriggerOutput<JobPollingState>> {
+ *     const jobId = await startJob(params);
+ *     return StepOutputs.triggered({ jobId, startedAt: Date.now() });
+ *   }
+ *
+ *   async poll(params: JobParams, state: JobPollingState): Promise<PollOutput<JobPollingState>> {
+ *     const status = await checkJob(state.jobId);
+ *     if (status === "running") {
+ *       return StepOutputs.pollAgain(state, 5000);
+ *     }
+ *     return StepOutputs.success({ result: status });
+ *   }
+ * }
+ * ```
+ *
+ * @example With approval
+ * ```typescript
+ * @Step({ name: "Dangerous Job", type: "dangerous-job", schema: dangerousSchema })
+ * class DangerousJobStep extends PollingStep<DangerousParams, DangerousPollingState> {
+ *   async prepare(params: DangerousParams): Promise<PrepareOutput> {
+ *     return StepOutputs.approvalRequired({
+ *       message: `Run dangerous job on ${params.target}?`,
+ *     });
+ *   }
+ *
+ *   async trigger(params: DangerousParams, approval: ApprovalContext): Promise<TriggerOutput<DangerousPollingState>> {
+ *     const jobId = await startDangerousJob(params);
+ *     return StepOutputs.triggered({ jobId });
+ *   }
+ *
+ *   async poll(params: DangerousParams, state: DangerousPollingState): Promise<PollOutput<DangerousPollingState>> {
+ *     // ... check status
+ *   }
+ * }
+ * ```
+ */
+class PollingStep extends base_step_1.BaseStep {
+    /**
+     * Called by the registry to execute the trigger phase.
+     * @internal
+     */
+    async executeTrigger(params, approval) {
+        return this.trigger(params, approval);
+    }
+    /**
+     * Called by the registry to execute the poll phase.
+     * @internal
+     */
+    async executePoll(params, pollingState) {
+        return this.poll(params, pollingState);
+    }
+    getMetadata() {
+        throw new Error("getMetadata not implemented. Did you forget to add the @Step decorator?");
+    }
+}
+exports.PollingStep = PollingStep;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/base/requires-approval-step.d.ts

@@ -0,0 +1,5 @@
+import { BaseStep } from "./base-step";
+export declare abstract class RequiresApprovalStep<T> extends BaseStep<T> {
+    abstract run(): Promise<void>;
+    abstract runAfterApproval(): Promise<void>;
+}

package/dist/base/requires-approval-step.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequiresApprovalStep = void 0;
+const base_step_1 = require("./base-step");
+class RequiresApprovalStep extends base_step_1.BaseStep {
+}
+exports.RequiresApprovalStep = RequiresApprovalStep;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVxdWlyZXMtYXBwcm92YWwtc3RlcC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9iYXNlL3JlcXVpcmVzLWFwcHJvdmFsLXN0ZXAudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsMkNBQXVDO0FBRXZDLE1BQXNCLG9CQUF3QixTQUFRLG9CQUFXO0NBR2hFO0FBSEQsb0RBR0MiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBCYXNlU3RlcCB9IGZyb20gXCIuL2Jhc2Utc3RlcFwiO1xuXG5leHBvcnQgYWJzdHJhY3QgY2xhc3MgUmVxdWlyZXNBcHByb3ZhbFN0ZXA8VD4gZXh0ZW5kcyBCYXNlU3RlcDxUPiB7XG4gIGFic3RyYWN0IHJ1bigpOiBQcm9taXNlPHZvaWQ+O1xuICBhYnN0cmFjdCBydW5BZnRlckFwcHJvdmFsKCk6IFByb21pc2U8dm9pZD47XG59XG4iXX0=

package/dist/base/simple-step.d.ts

@@ -0,0 +1,51 @@
+import type { StepMetadata } from "./base-step";
+import { BaseStep } from "./base-step";
+import type { ApprovalContext, RunOutput, StepOutput } from "../output/step-output";
+/**
+ * A simple step that runs once with the provided params.
+ *
+ * Users extend this class and implement the `run` method.
+ * Optionally override `prepare` to require approval before execution.
+ *
+ * @example
+ * ```typescript
+ * @Step({ name: "Deploy", type: "deploy", schema: deploySchema })
+ * class DeployStep extends SimpleStep<DeployParams> {
+ *   async run(params: DeployParams): Promise<RunOutput> {
+ *     this.logger.info("Deploying", { target: params.target });
+ *     return StepOutputs.success({ deploymentId: "123" });
+ *   }
+ * }
+ * ```
+ *
+ * @example With approval
+ * ```typescript
+ * @Step({ name: "Delete User", type: "delete-user", schema: deleteUserSchema })
+ * class DeleteUserStep extends SimpleStep<DeleteUserParams> {
+ *   async prepare(params: DeleteUserParams): Promise<PrepareOutput> {
+ *     return StepOutputs.approvalRequired({
+ *       message: `Delete user ${params.userId}?`,
+ *     });
+ *   }
+ *
+ *   async run(params: DeleteUserParams, approval: ApprovalContext): Promise<RunOutput> {
+ *     this.logger.info("Deleting user", { approvedBy: approval.approverId });
+ *     return StepOutputs.success();
+ *   }
+ * }
+ * ```
+ */
+export declare abstract class SimpleStep<TParams> extends BaseStep<TParams> {
+    /**
+     * Execute the step logic.
+     * @param params - The validated input parameters
+     * @param approval - Approval context if this step requires approval (has prepare method)
+     */
+    abstract run(params: TParams, approval?: ApprovalContext): Promise<RunOutput>;
+    /**
+     * Called by the registry to execute this step.
+     * @internal
+     */
+    execute(params: TParams, approval?: ApprovalContext): Promise<StepOutput>;
+    getMetadata(): StepMetadata;
+}

package/dist/base/simple-step.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimpleStep = void 0;
+const base_step_1 = require("./base-step");
+/**
+ * A simple step that runs once with the provided params.
+ *
+ * Users extend this class and implement the `run` method.
+ * Optionally override `prepare` to require approval before execution.
+ *
+ * @example
+ * ```typescript
+ * @Step({ name: "Deploy", type: "deploy", schema: deploySchema })
+ * class DeployStep extends SimpleStep<DeployParams> {
+ *   async run(params: DeployParams): Promise<RunOutput> {
+ *     this.logger.info("Deploying", { target: params.target });
+ *     return StepOutputs.success({ deploymentId: "123" });
+ *   }
+ * }
+ * ```
+ *
+ * @example With approval
+ * ```typescript
+ * @Step({ name: "Delete User", type: "delete-user", schema: deleteUserSchema })
+ * class DeleteUserStep extends SimpleStep<DeleteUserParams> {
+ *   async prepare(params: DeleteUserParams): Promise<PrepareOutput> {
+ *     return StepOutputs.approvalRequired({
+ *       message: `Delete user ${params.userId}?`,
+ *     });
+ *   }
+ *
+ *   async run(params: DeleteUserParams, approval: ApprovalContext): Promise<RunOutput> {
+ *     this.logger.info("Deleting user", { approvedBy: approval.approverId });
+ *     return StepOutputs.success();
+ *   }
+ * }
+ * ```
+ */
+class SimpleStep extends base_step_1.BaseStep {
+    /**
+     * Called by the registry to execute this step.
+     * @internal
+     */
+    async execute(params, approval) {
+        return this.run(params, approval);
+    }
+    getMetadata() {
+        throw new Error("getMetadata not implemented. Did you forget to add the @Step decorator?");
+    }
+}
+exports.SimpleStep = SimpleStep;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/decorators/step.d.ts

@@ -0,0 +1,24 @@
+import type { ZodType, z } from "zod";
+import { BaseStep } from "../base/base-step";
+export interface StepConfig<S extends ZodType> {
+    name: string;
+    type: string;
+    schema: S;
+}
+/**
+ * Decorator that adds metadata to a step class.
+ * This is required for all steps to be registered with StepRegistry.
+ *
+ * The decorated class must extend SimpleStep or PollingStep.
+ *
+ * @example
+ * ```typescript
+ * @Step({ name: "My Step", type: "my-step", schema: mySchema })
+ * class MyStep extends SimpleStep<MyParams> {
+ *   async run(params: MyParams): Promise<RunOutput> {
+ *     return StepOutputs.success();
+ *   }
+ * }
+ * ```
+ */
+export declare function Step<S extends ZodType>(config: StepConfig<S>): <T extends new (...args: any[]) => BaseStep<z.infer<S>>>(Base: T) => T;

package/dist/decorators/step.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Step = Step;
+const base_step_1 = require("../base/base-step");
+/**
+ * Decorator that adds metadata to a step class.
+ * This is required for all steps to be registered with StepRegistry.
+ *
+ * The decorated class must extend SimpleStep or PollingStep.
+ *
+ * @example
+ * ```typescript
+ * @Step({ name: "My Step", type: "my-step", schema: mySchema })
+ * class MyStep extends SimpleStep<MyParams> {
+ *   async run(params: MyParams): Promise<RunOutput> {
+ *     return StepOutputs.success();
+ *   }
+ * }
+ * ```
+ */
+function Step(config) {
+    return function (Base) {
+        const Enhanced = class extends Base {
+            getMetadata() {
+                // Detect step kind by checking for PollingStep methods
+                const hasPollingMethods = "trigger" in this &&
+                    typeof this.trigger === "function" &&
+                    "poll" in this &&
+                    typeof this.poll === "function";
+                const stepKind = hasPollingMethods ? "polling" : "simple";
+                // Check if prepare is overridden (not the default BaseStep.prepare)
+                const requiresApproval = this.prepare !== base_step_1.BaseStep.prototype.prepare;
+                return {
+                    type: config.type,
+                    name: config.name,
+                    schema: config.schema,
+                    stepKind,
+                    requiresApproval,
+                };
+            }
+        };
+        return Enhanced;
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { BaseStep, StepClass, StepMetadata, StepKind } from "./base/base-step";
+export { SimpleStep } from "./base/simple-step";
+export { PollingStep } from "./base/polling-step";
+export { Step, StepConfig } from "./decorators/step";
+export { ApprovalContext, ApprovalContextSchema, PrepareOutput, RunOutput, TriggerOutput, TriggeredOutput, PollOutput, PollAgainOutput, SuccessOutput, FailedOutput, ApprovalRequiredOutput, StepOutput, PrepareOutputSchema, RunOutputSchema, TriggerOutputSchema, PollOutputSchema, StepOutputSchema, StepOutputs, } from "./output/step-output";
+export { StepRegistry, StepRegistryInput, StepRegistryInputSchema } from "./registry/step-registry";
+export { StepLogger, StepLoggerConfig, LogEntry, LogLevel } from "./logging/step-logger";

package/dist/index.js

@@ -0,0 +1,35 @@
+"use strict";
+// =============================================================================
+// Step SDK - Public API
+// =============================================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StepLogger = exports.StepRegistryInputSchema = exports.StepRegistry = exports.StepOutputs = exports.StepOutputSchema = exports.PollOutputSchema = exports.TriggerOutputSchema = exports.RunOutputSchema = exports.PrepareOutputSchema = exports.ApprovalContextSchema = exports.Step = exports.PollingStep = exports.SimpleStep = exports.BaseStep = void 0;
+// Base classes for creating steps
+var base_step_1 = require("./base/base-step");
+Object.defineProperty(exports, "BaseStep", { enumerable: true, get: function () { return base_step_1.BaseStep; } });
+var simple_step_1 = require("./base/simple-step");
+Object.defineProperty(exports, "SimpleStep", { enumerable: true, get: function () { return simple_step_1.SimpleStep; } });
+var polling_step_1 = require("./base/polling-step");
+Object.defineProperty(exports, "PollingStep", { enumerable: true, get: function () { return polling_step_1.PollingStep; } });
+// Decorator for adding metadata to steps
+var step_1 = require("./decorators/step");
+Object.defineProperty(exports, "Step", { enumerable: true, get: function () { return step_1.Step; } });
+// Output types and helper functions
+var step_output_1 = require("./output/step-output");
+Object.defineProperty(exports, "ApprovalContextSchema", { enumerable: true, get: function () { return step_output_1.ApprovalContextSchema; } });
+// Output schemas for validation
+Object.defineProperty(exports, "PrepareOutputSchema", { enumerable: true, get: function () { return step_output_1.PrepareOutputSchema; } });
+Object.defineProperty(exports, "RunOutputSchema", { enumerable: true, get: function () { return step_output_1.RunOutputSchema; } });
+Object.defineProperty(exports, "TriggerOutputSchema", { enumerable: true, get: function () { return step_output_1.TriggerOutputSchema; } });
+Object.defineProperty(exports, "PollOutputSchema", { enumerable: true, get: function () { return step_output_1.PollOutputSchema; } });
+Object.defineProperty(exports, "StepOutputSchema", { enumerable: true, get: function () { return step_output_1.StepOutputSchema; } });
+// Helper functions
+Object.defineProperty(exports, "StepOutputs", { enumerable: true, get: function () { return step_output_1.StepOutputs; } });
+// Registry for running steps
+var step_registry_1 = require("./registry/step-registry");
+Object.defineProperty(exports, "StepRegistry", { enumerable: true, get: function () { return step_registry_1.StepRegistry; } });
+Object.defineProperty(exports, "StepRegistryInputSchema", { enumerable: true, get: function () { return step_registry_1.StepRegistryInputSchema; } });
+// Logging
+var step_logger_1 = require("./logging/step-logger");
+Object.defineProperty(exports, "StepLogger", { enumerable: true, get: function () { return step_logger_1.StepLogger; } });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/logging/step-logger.d.ts

@@ -0,0 +1,35 @@
+export type LogLevel = "info" | "error";
+export interface LogEntry {
+    timestamp: string;
+    level: LogLevel;
+    message: string;
+    data?: Record<string, unknown>;
+    stepType: string;
+    executionId: string;
+}
+export interface StepLoggerConfig {
+    logDir: string;
+    executionId: string;
+    stepType: string;
+}
+/**
+ * File-based structured logger for steps.
+ * Writes JSON lines to {logDir}/{executionId}.jsonl
+ */
+export declare class StepLogger {
+    private readonly logFilePath;
+    private readonly stepType;
+    private readonly executionId;
+    constructor(config: StepLoggerConfig);
+    info(message: string, data?: Record<string, unknown>): void;
+    error(message: string, data?: Record<string, unknown>): void;
+    private write;
+}
+/**
+ * No-op logger for use when logging is not configured.
+ */
+export declare class NoOpLogger extends StepLogger {
+    constructor();
+    info(_message: string, _data?: Record<string, unknown>): void;
+    error(_message: string, _data?: Record<string, unknown>): void;
+}

package/dist/logging/step-logger.js

@@ -0,0 +1,94 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoOpLogger = exports.StepLogger = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * File-based structured logger for steps.
+ * Writes JSON lines to {logDir}/{executionId}.jsonl
+ */
+class StepLogger {
+    logFilePath;
+    stepType;
+    executionId;
+    constructor(config) {
+        this.stepType = config.stepType;
+        this.executionId = config.executionId;
+        this.logFilePath = path.join(config.logDir, `${config.executionId}.jsonl`);
+        // Ensure log directory exists
+        const logDir = path.dirname(this.logFilePath);
+        if (!fs.existsSync(logDir)) {
+            fs.mkdirSync(logDir, { recursive: true });
+        }
+    }
+    info(message, data) {
+        this.write("info", message, data);
+    }
+    error(message, data) {
+        this.write("error", message, data);
+    }
+    write(level, message, data) {
+        const entry = {
+            timestamp: new Date().toISOString(),
+            level,
+            message,
+            stepType: this.stepType,
+            executionId: this.executionId,
+        };
+        if (data !== undefined) {
+            entry.data = data;
+        }
+        fs.appendFileSync(this.logFilePath, JSON.stringify(entry) + "\n");
+    }
+}
+exports.StepLogger = StepLogger;
+/**
+ * No-op logger for use when logging is not configured.
+ */
+class NoOpLogger extends StepLogger {
+    constructor() {
+        // Pass dummy config - methods are overridden anyway
+        super({ logDir: "/tmp", executionId: "noop", stepType: "noop" });
+    }
+    info(_message, _data) {
+        // No-op
+    }
+    error(_message, _data) {
+        // No-op
+    }
+}
+exports.NoOpLogger = NoOpLogger;
+//# sourceMappingURL=data:application/json;base64,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