@devramps/sdk-typescript 0.1.3 → 0.1.5

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

@@ -1,18 +1,21 @@
-import type { ZodType, z } from "zod";
+import type { ZodType } from "zod";
 import type { StepLogger } from "../logging/step-logger";
 import type { PrepareOutput } from "../output/step-output";
 import type { ZodStandardJSONSchemaPayload } from "zod/v4/core";
 export type StepKind = "simple" | "polling";
+export interface StepData<S extends ZodType = ZodType> {
+    schema: S;
+    stepType: string;
+    stepKind: StepKind;
+    requiresApproval: boolean;
+}
 export interface StepMetadata<S extends ZodType = ZodType> {
     name?: string;
     shortDescription?: string;
     longDescription?: string;
     yamlExample?: string;
-    schema: S;
-    stepKind: StepKind;
-    requiresApproval: boolean;
     stepType: string;
-    jsonSchema: ZodStandardJSONSchemaPayload<S>;
+    paramsJsonSchema: ZodStandardJSONSchemaPayload<S>;
     documentationUrl?: string;
 }
 /**
@@ -31,6 +34,7 @@ export declare abstract class BaseStep<TParams = unknown> {
      * Implemented by the @Step decorator.
      */
     getMetadata(): StepMetadata;
+    getData(): StepData;
     /**
      * Optional prepare method for approval flow.
      * Override this to require approval before execution.
@@ -38,10 +42,3 @@ export declare abstract class BaseStep<TParams = unknown> {
      */
     prepare(_params: TParams): Promise<PrepareOutput>;
 }
-/**
- * Type representing a class constructor that produces a BaseStep instance
- * with the getMetadata method available.
- */
-export type StepClass<S extends ZodType = ZodType> = new (...args: any[]) => BaseStep<z.infer<S>> & {
-    getMetadata(): StepMetadata<S>;
-};

package/dist/base/base-step.js

@@ -23,6 +23,9 @@ class BaseStep {
     getMetadata() {
         throw new Error("getMetadata not implemented. Did you forget to add the @Step decorator?");
     }
+    getData() {
+        throw new Error("getData not implemented. Did you forget to add the @Step decorator?");
+    }
     /**
      * Optional prepare method for approval flow.
      * Override this to require approval before execution.
@@ -35,4 +38,4 @@ class BaseStep {
     }
 }
 exports.BaseStep = BaseStep;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -10,6 +10,8 @@ import type { ApprovalContext, PollOutput, StepOutput, TriggerOutput } from "../
  *
  * Optionally override `prepare` to require approval before triggering.
  *
+ * Steps can accept constructor parameters for dependency injection.
+ *
  * @typeParam TParams - The input parameters type (validated by schema)
  * @typeParam TPollingState - The polling state type passed between poll calls
  *
@@ -20,25 +22,36 @@ import type { ApprovalContext, PollOutput, StepOutput, TriggerOutput } from "../
  *
  * @Step({ name: "Long Job", type: "long-job", schema: jobSchema })
  * class LongJobStep extends PollingStep<JobParams, JobPollingState> {
+ *   constructor(private jobService: JobService) {
+ *     super();
+ *   }
+ *
  *   async trigger(params: JobParams): Promise<TriggerOutput<JobPollingState>> {
- *     const jobId = await startJob(params);
+ *     const jobId = await this.jobService.start(params);
  *     return StepOutputs.triggered({ jobId, startedAt: Date.now() });
  *   }
  *
  *   async poll(params: JobParams, state: JobPollingState): Promise<PollOutput<JobPollingState>> {
- *     const status = await checkJob(state.jobId);
+ *     const status = await this.jobService.checkStatus(state.jobId);
  *     if (status === "running") {
  *       return StepOutputs.pollAgain(state, 5000);
  *     }
  *     return StepOutputs.success({ result: status });
  *   }
  * }
+ *
+ * // Register with dependency injected
+ * StepRegistry.run([new LongJobStep(jobService)]);
  * ```
  *
  * @example With approval
  * ```typescript
  * @Step({ name: "Dangerous Job", type: "dangerous-job", schema: dangerousSchema })
  * class DangerousJobStep extends PollingStep<DangerousParams, DangerousPollingState> {
+ *   constructor(private jobService: JobService) {
+ *     super();
+ *   }
+ *
  *   async prepare(params: DangerousParams): Promise<PrepareOutput> {
  *     return StepOutputs.approvalRequired({
  *       message: `Run dangerous job on ${params.target}?`,
@@ -46,12 +59,16 @@ import type { ApprovalContext, PollOutput, StepOutput, TriggerOutput } from "../
  *   }
  *
  *   async trigger(params: DangerousParams, approval: ApprovalContext): Promise<TriggerOutput<DangerousPollingState>> {
- *     const jobId = await startDangerousJob(params);
+ *     const jobId = await this.jobService.startDangerous(params);
  *     return StepOutputs.triggered({ jobId });
  *   }
  *
  *   async poll(params: DangerousParams, state: DangerousPollingState): Promise<PollOutput<DangerousPollingState>> {
- *     // ... check status
+ *     const status = await this.jobService.checkStatus(state.jobId);
+ *     if (status === "running") {
+ *       return StepOutputs.pollAgain(state, 5000);
+ *     }
+ *     return StepOutputs.success();
  *   }
  * }
  * ```

package/dist/base/polling-step.js

@@ -11,6 +11,8 @@ const base_step_1 = require("./base-step");
  *
  * Optionally override `prepare` to require approval before triggering.
  *
+ * Steps can accept constructor parameters for dependency injection.
+ *
  * @typeParam TParams - The input parameters type (validated by schema)
  * @typeParam TPollingState - The polling state type passed between poll calls
  *
@@ -21,25 +23,36 @@ const base_step_1 = require("./base-step");
  *
  * @Step({ name: "Long Job", type: "long-job", schema: jobSchema })
  * class LongJobStep extends PollingStep<JobParams, JobPollingState> {
+ *   constructor(private jobService: JobService) {
+ *     super();
+ *   }
+ *
  *   async trigger(params: JobParams): Promise<TriggerOutput<JobPollingState>> {
- *     const jobId = await startJob(params);
+ *     const jobId = await this.jobService.start(params);
  *     return StepOutputs.triggered({ jobId, startedAt: Date.now() });
  *   }
  *
  *   async poll(params: JobParams, state: JobPollingState): Promise<PollOutput<JobPollingState>> {
- *     const status = await checkJob(state.jobId);
+ *     const status = await this.jobService.checkStatus(state.jobId);
  *     if (status === "running") {
  *       return StepOutputs.pollAgain(state, 5000);
  *     }
  *     return StepOutputs.success({ result: status });
  *   }
  * }
+ *
+ * // Register with dependency injected
+ * StepRegistry.run([new LongJobStep(jobService)]);
  * ```
  *
  * @example With approval
  * ```typescript
  * @Step({ name: "Dangerous Job", type: "dangerous-job", schema: dangerousSchema })
  * class DangerousJobStep extends PollingStep<DangerousParams, DangerousPollingState> {
+ *   constructor(private jobService: JobService) {
+ *     super();
+ *   }
+ *
  *   async prepare(params: DangerousParams): Promise<PrepareOutput> {
  *     return StepOutputs.approvalRequired({
  *       message: `Run dangerous job on ${params.target}?`,
@@ -47,12 +60,16 @@ const base_step_1 = require("./base-step");
  *   }
  *
  *   async trigger(params: DangerousParams, approval: ApprovalContext): Promise<TriggerOutput<DangerousPollingState>> {
- *     const jobId = await startDangerousJob(params);
+ *     const jobId = await this.jobService.startDangerous(params);
  *     return StepOutputs.triggered({ jobId });
  *   }
  *
  *   async poll(params: DangerousParams, state: DangerousPollingState): Promise<PollOutput<DangerousPollingState>> {
- *     // ... check status
+ *     const status = await this.jobService.checkStatus(state.jobId);
+ *     if (status === "running") {
+ *       return StepOutputs.pollAgain(state, 5000);
+ *     }
+ *     return StepOutputs.success();
  *   }
  * }
  * ```
@@ -77,4 +94,4 @@ class PollingStep extends base_step_1.BaseStep {
     }
 }
 exports.PollingStep = PollingStep;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -7,21 +7,35 @@ import type { ApprovalContext, RunOutput, StepOutput } from "../output/step-outp
  * Users extend this class and implement the `run` method.
  * Optionally override `prepare` to require approval before execution.
  *
+ * Steps can accept constructor parameters for dependency injection.
+ *
  * @example
  * ```typescript
  * @Step({ name: "Deploy", type: "deploy", schema: deploySchema })
  * class DeployStep extends SimpleStep<DeployParams> {
+ *   constructor(private deployService: DeployService) {
+ *     super();
+ *   }
+ *
  *   async run(params: DeployParams): Promise<RunOutput> {
  *     this.logger.info("Deploying", { target: params.target });
- *     return StepOutputs.success({ deploymentId: "123" });
+ *     const result = await this.deployService.deploy(params.target);
+ *     return StepOutputs.success({ deploymentId: result.id });
  *   }
  * }
+ *
+ * // Register with dependency injected
+ * StepRegistry.run([new DeployStep(deployService)]);
  * ```
  *
  * @example With approval
  * ```typescript
  * @Step({ name: "Delete User", type: "delete-user", schema: deleteUserSchema })
  * class DeleteUserStep extends SimpleStep<DeleteUserParams> {
+ *   constructor(private userService: UserService) {
+ *     super();
+ *   }
+ *
  *   async prepare(params: DeleteUserParams): Promise<PrepareOutput> {
  *     return StepOutputs.approvalRequired({
  *       message: `Delete user ${params.userId}?`,
@@ -30,6 +44,7 @@ import type { ApprovalContext, RunOutput, StepOutput } from "../output/step-outp
  *
  *   async run(params: DeleteUserParams, approval: ApprovalContext): Promise<RunOutput> {
  *     this.logger.info("Deleting user", { approvedBy: approval.approverId });
+ *     await this.userService.delete(params.userId);
  *     return StepOutputs.success();
  *   }
  * }

package/dist/base/simple-step.js

@@ -8,21 +8,35 @@ const base_step_1 = require("./base-step");
  * Users extend this class and implement the `run` method.
  * Optionally override `prepare` to require approval before execution.
  *
+ * Steps can accept constructor parameters for dependency injection.
+ *
  * @example
  * ```typescript
  * @Step({ name: "Deploy", type: "deploy", schema: deploySchema })
  * class DeployStep extends SimpleStep<DeployParams> {
+ *   constructor(private deployService: DeployService) {
+ *     super();
+ *   }
+ *
  *   async run(params: DeployParams): Promise<RunOutput> {
  *     this.logger.info("Deploying", { target: params.target });
- *     return StepOutputs.success({ deploymentId: "123" });
+ *     const result = await this.deployService.deploy(params.target);
+ *     return StepOutputs.success({ deploymentId: result.id });
  *   }
  * }
+ *
+ * // Register with dependency injected
+ * StepRegistry.run([new DeployStep(deployService)]);
  * ```
  *
  * @example With approval
  * ```typescript
  * @Step({ name: "Delete User", type: "delete-user", schema: deleteUserSchema })
  * class DeleteUserStep extends SimpleStep<DeleteUserParams> {
+ *   constructor(private userService: UserService) {
+ *     super();
+ *   }
+ *
  *   async prepare(params: DeleteUserParams): Promise<PrepareOutput> {
  *     return StepOutputs.approvalRequired({
  *       message: `Delete user ${params.userId}?`,
@@ -31,6 +45,7 @@ const base_step_1 = require("./base-step");
  *
  *   async run(params: DeleteUserParams, approval: ApprovalContext): Promise<RunOutput> {
  *     this.logger.info("Deleting user", { approvedBy: approval.approverId });
+ *     await this.userService.delete(params.userId);
  *     return StepOutputs.success();
  *   }
  * }
@@ -49,4 +64,4 @@ class SimpleStep extends base_step_1.BaseStep {
     }
 }
 exports.SimpleStep = SimpleStep;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2ltcGxlLXN0ZXAuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYmFzZS9zaW1wbGUtc3RlcC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFDQSwyQ0FBdUM7QUFHdkM7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztHQWlDRztBQUNILE1BQXNCLFVBQW9CLFNBQVEsb0JBQWlCO0lBUWpFOzs7T0FHRztJQUNILEtBQUssQ0FBQyxPQUFPLENBQUMsTUFBZSxFQUFFLFFBQTBCO1FBQ3ZELE9BQU8sSUFBSSxDQUFDLEdBQUcsQ0FBQyxNQUFNLEVBQUUsUUFBUSxDQUFDLENBQUM7SUFDcEMsQ0FBQztJQUVELFdBQVc7UUFDVCxNQUFNLElBQUksS0FBSyxDQUNiLHlFQUF5RSxDQUMxRSxDQUFDO0lBQ0osQ0FBQztDQUNGO0FBckJELGdDQXFCQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgU3RlcE1ldGFkYXRhIH0gZnJvbSBcIi4vYmFzZS1zdGVwXCI7XG5pbXBvcnQgeyBCYXNlU3RlcCB9IGZyb20gXCIuL2Jhc2Utc3RlcFwiO1xuaW1wb3J0IHR5cGUgeyBBcHByb3ZhbENvbnRleHQsIFJ1bk91dHB1dCwgU3RlcE91dHB1dCB9IGZyb20gXCIuLi9vdXRwdXQvc3RlcC1vdXRwdXRcIjtcblxuLyoqXG4gKiBBIHNpbXBsZSBzdGVwIHRoYXQgcnVucyBvbmNlIHdpdGggdGhlIHByb3ZpZGVkIHBhcmFtcy5cbiAqXG4gKiBVc2VycyBleHRlbmQgdGhpcyBjbGFzcyBhbmQgaW1wbGVtZW50IHRoZSBgcnVuYCBtZXRob2QuXG4gKiBPcHRpb25hbGx5IG92ZXJyaWRlIGBwcmVwYXJlYCB0byByZXF1aXJlIGFwcHJvdmFsIGJlZm9yZSBleGVjdXRpb24uXG4gKlxuICogQGV4YW1wbGVcbiAqIGBgYHR5cGVzY3JpcHRcbiAqIEBTdGVwKHsgbmFtZTogXCJEZXBsb3lcIiwgdHlwZTogXCJkZXBsb3lcIiwgc2NoZW1hOiBkZXBsb3lTY2hlbWEgfSlcbiAqIGNsYXNzIERlcGxveVN0ZXAgZXh0ZW5kcyBTaW1wbGVTdGVwPERlcGxveVBhcmFtcz4ge1xuICogICBhc3luYyBydW4ocGFyYW1zOiBEZXBsb3lQYXJhbXMpOiBQcm9taXNlPFJ1bk91dHB1dD4ge1xuICogICAgIHRoaXMubG9nZ2VyLmluZm8oXCJEZXBsb3lpbmdcIiwgeyB0YXJnZXQ6IHBhcmFtcy50YXJnZXQgfSk7XG4gKiAgICAgcmV0dXJuIFN0ZXBPdXRwdXRzLnN1Y2Nlc3MoeyBkZXBsb3ltZW50SWQ6IFwiMTIzXCIgfSk7XG4gKiAgIH1cbiAqIH1cbiAqIGBgYFxuICpcbiAqIEBleGFtcGxlIFdpdGggYXBwcm92YWxcbiAqIGBgYHR5cGVzY3JpcHRcbiAqIEBTdGVwKHsgbmFtZTogXCJEZWxldGUgVXNlclwiLCB0eXBlOiBcImRlbGV0ZS11c2VyXCIsIHNjaGVtYTogZGVsZXRlVXNlclNjaGVtYSB9KVxuICogY2xhc3MgRGVsZXRlVXNlclN0ZXAgZXh0ZW5kcyBTaW1wbGVTdGVwPERlbGV0ZVVzZXJQYXJhbXM+IHtcbiAqICAgYXN5bmMgcHJlcGFyZShwYXJhbXM6IERlbGV0ZVVzZXJQYXJhbXMpOiBQcm9taXNlPFByZXBhcmVPdXRwdXQ+IHtcbiAqICAgICByZXR1cm4gU3RlcE91dHB1dHMuYXBwcm92YWxSZXF1aXJlZCh7XG4gKiAgICAgICBtZXNzYWdlOiBgRGVsZXRlIHVzZXIgJHtwYXJhbXMudXNlcklkfT9gLFxuICogICAgIH0pO1xuICogICB9XG4gKlxuICogICBhc3luYyBydW4ocGFyYW1zOiBEZWxldGVVc2VyUGFyYW1zLCBhcHByb3ZhbDogQXBwcm92YWxDb250ZXh0KTogUHJvbWlzZTxSdW5PdXRwdXQ+IHtcbiAqICAgICB0aGlzLmxvZ2dlci5pbmZvKFwiRGVsZXRpbmcgdXNlclwiLCB7IGFwcHJvdmVkQnk6IGFwcHJvdmFsLmFwcHJvdmVySWQgfSk7XG4gKiAgICAgcmV0dXJuIFN0ZXBPdXRwdXRzLnN1Y2Nlc3MoKTtcbiAqICAgfVxuICogfVxuICogYGBgXG4gKi9cbmV4cG9ydCBhYnN0cmFjdCBjbGFzcyBTaW1wbGVTdGVwPFRQYXJhbXM+IGV4dGVuZHMgQmFzZVN0ZXA8VFBhcmFtcz4ge1xuICAvKipcbiAgICogRXhlY3V0ZSB0aGUgc3RlcCBsb2dpYy5cbiAgICogQHBhcmFtIHBhcmFtcyAtIFRoZSB2YWxpZGF0ZWQgaW5wdXQgcGFyYW1ldGVyc1xuICAgKiBAcGFyYW0gYXBwcm92YWwgLSBBcHByb3ZhbCBjb250ZXh0IGlmIHRoaXMgc3RlcCByZXF1aXJlcyBhcHByb3ZhbCAoaGFzIHByZXBhcmUgbWV0aG9kKVxuICAgKi9cbiAgYWJzdHJhY3QgcnVuKHBhcmFtczogVFBhcmFtcywgYXBwcm92YWw/OiBBcHByb3ZhbENvbnRleHQpOiBQcm9taXNlPFJ1bk91dHB1dD47XG5cbiAgLyoqXG4gICAqIENhbGxlZCBieSB0aGUgcmVnaXN0cnkgdG8gZXhlY3V0ZSB0aGlzIHN0ZXAuXG4gICAqIEBpbnRlcm5hbFxuICAgKi9cbiAgYXN5bmMgZXhlY3V0ZShwYXJhbXM6IFRQYXJhbXMsIGFwcHJvdmFsPzogQXBwcm92YWxDb250ZXh0KTogUHJvbWlzZTxTdGVwT3V0cHV0PiB7XG4gICAgcmV0dXJuIHRoaXMucnVuKHBhcmFtcywgYXBwcm92YWwpO1xuICB9XG5cbiAgZ2V0TWV0YWRhdGEoKTogU3RlcE1ldGFkYXRhIHtcbiAgICB0aHJvdyBuZXcgRXJyb3IoXG4gICAgICBcImdldE1ldGFkYXRhIG5vdCBpbXBsZW1lbnRlZC4gRGlkIHlvdSBmb3JnZXQgdG8gYWRkIHRoZSBAU3RlcCBkZWNvcmF0b3I/XCJcbiAgICApO1xuICB9XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

package/dist/decorators/step.d.ts

@@ -1,6 +1,6 @@
 import { type ZodType, z } from "zod";
 import { BaseStep } from "../base/base-step";
-export interface StepConfig<S extends ZodType> {
+export interface StepConfig<S extends ZodType = ZodType> {
     name?: string;
     type: string;
     shortDescription?: string;
@@ -18,10 +18,18 @@ export interface StepConfig<S extends ZodType> {
  * ```typescript
  * @Step({ name: "My Step", type: "my-step", schema: mySchema })
  * class MyStep extends SimpleStep<MyParams> {
+ *   constructor(private apiClient: ApiClient) {
+ *     super();
+ *   }
+ *
  *   async run(params: MyParams): Promise<RunOutput> {
+ *     await this.apiClient.doSomething();
  *     return StepOutputs.success();
  *   }
  * }
+ *
+ * // Register with dependencies injected
+ * StepRegistry.run([new MyStep(apiClient)]);
  * ```
  */
 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

@@ -13,16 +13,34 @@ const base_step_1 = require("../base/base-step");
  * ```typescript
  * @Step({ name: "My Step", type: "my-step", schema: mySchema })
  * class MyStep extends SimpleStep<MyParams> {
+ *   constructor(private apiClient: ApiClient) {
+ *     super();
+ *   }
+ *
  *   async run(params: MyParams): Promise<RunOutput> {
+ *     await this.apiClient.doSomething();
  *     return StepOutputs.success();
  *   }
  * }
+ *
+ * // Register with dependencies injected
+ * StepRegistry.run([new MyStep(apiClient)]);
  * ```
  */
 function Step(config) {
     return function (Base) {
         const Enhanced = class extends Base {
             getMetadata() {
+                return {
+                    name: config.name,
+                    stepType: config.type,
+                    shortDescription: config.shortDescription,
+                    longDescription: config.longDescription,
+                    yamlExample: config.yamlExample,
+                    paramsJsonSchema: zod_1.z.toJSONSchema(config.schema),
+                };
+            }
+            getData() {
                 // Detect step kind by checking for PollingStep methods
                 const hasPollingMethods = "trigger" in this &&
                     typeof this.trigger === "function" &&
@@ -32,13 +50,8 @@ function Step(config) {
                 // Check if prepare is overridden (not the default BaseStep.prepare)
                 const requiresApproval = this.prepare !== base_step_1.BaseStep.prototype.prepare;
                 return {
-                    name: config.name,
                     stepType: config.type,
-                    shortDescription: config.shortDescription,
-                    longDescription: config.longDescription,
-                    yamlExample: config.yamlExample,
                     schema: config.schema,
-                    jsonSchema: zod_1.z.toJSONSchema(config.schema),
                     stepKind,
                     requiresApproval,
                 };
@@ -47,4 +60,4 @@ function Step(config) {
         return Enhanced;
     };
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { BaseStep, StepClass, StepMetadata, StepKind } from "./base/base-step";
+export { BaseStep, StepMetadata, StepKind } from "./base/base-step";
 export { SimpleStep } from "./base/simple-step";
 export { PollingStep } from "./base/polling-step";
 export { Step, StepConfig } from "./decorators/step";

package/dist/index.js

@@ -32,4 +32,4 @@ Object.defineProperty(exports, "StepRegistryInputSchema", { enumerable: true, ge
 // 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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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLGdGQUFnRjtBQUNoRix3QkFBd0I7QUFDeEIsZ0ZBQWdGOzs7QUFFaEYsa0NBQWtDO0FBQ2xDLDhDQUFvRTtBQUEzRCxxR0FBQSxRQUFRLE9BQUE7QUFDakIsa0RBQWdEO0FBQXZDLHlHQUFBLFVBQVUsT0FBQTtBQUNuQixvREFBa0Q7QUFBekMsMkdBQUEsV0FBVyxPQUFBO0FBRXBCLHlDQUF5QztBQUN6QywwQ0FBcUQ7QUFBNUMsNEZBQUEsSUFBSSxPQUFBO0FBRWIsb0NBQW9DO0FBQ3BDLG9EQXlCOEI7QUF0QjVCLG9IQUFBLHFCQUFxQixPQUFBO0FBY3JCLGdDQUFnQztBQUNoQyxrSEFBQSxtQkFBbUIsT0FBQTtBQUNuQiw4R0FBQSxlQUFlLE9BQUE7QUFDZixrSEFBQSxtQkFBbUIsT0FBQTtBQUNuQiwrR0FBQSxnQkFBZ0IsT0FBQTtBQUNoQiwrR0FBQSxnQkFBZ0IsT0FBQTtBQUNoQixtQkFBbUI7QUFDbkIsMEdBQUEsV0FBVyxPQUFBO0FBR2IsNkJBQTZCO0FBQzdCLDBEQUFvRztBQUEzRiw2R0FBQSxZQUFZLE9BQUE7QUFBcUIsd0hBQUEsdUJBQXVCLE9BQUE7QUFFakUsVUFBVTtBQUNWLHFEQUF5RjtBQUFoRix5R0FBQSxVQUFVLE9BQUEiLCJzb3VyY2VzQ29udGVudCI6WyIvLyA9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PVxuLy8gU3RlcCBTREsgLSBQdWJsaWMgQVBJXG4vLyA9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PVxuXG4vLyBCYXNlIGNsYXNzZXMgZm9yIGNyZWF0aW5nIHN0ZXBzXG5leHBvcnQgeyBCYXNlU3RlcCwgU3RlcE1ldGFkYXRhLCBTdGVwS2luZCB9IGZyb20gXCIuL2Jhc2UvYmFzZS1zdGVwXCI7XG5leHBvcnQgeyBTaW1wbGVTdGVwIH0gZnJvbSBcIi4vYmFzZS9zaW1wbGUtc3RlcFwiO1xuZXhwb3J0IHsgUG9sbGluZ1N0ZXAgfSBmcm9tIFwiLi9iYXNlL3BvbGxpbmctc3RlcFwiO1xuXG4vLyBEZWNvcmF0b3IgZm9yIGFkZGluZyBtZXRhZGF0YSB0byBzdGVwc1xuZXhwb3J0IHsgU3RlcCwgU3RlcENvbmZpZyB9IGZyb20gXCIuL2RlY29yYXRvcnMvc3RlcFwiO1xuXG4vLyBPdXRwdXQgdHlwZXMgYW5kIGhlbHBlciBmdW5jdGlvbnNcbmV4cG9ydCB7XG4gIC8vIEFwcHJvdmFsIGNvbnRleHRcbiAgQXBwcm92YWxDb250ZXh0LFxuICBBcHByb3ZhbENvbnRleHRTY2hlbWEsXG4gIC8vIFBoYXNlLXNwZWNpZmljIG91dHB1dHNcbiAgUHJlcGFyZU91dHB1dCxcbiAgUnVuT3V0cHV0LFxuICBUcmlnZ2VyT3V0cHV0LFxuICBUcmlnZ2VyZWRPdXRwdXQsXG4gIFBvbGxPdXRwdXQsXG4gIFBvbGxBZ2Fpbk91dHB1dCxcbiAgLy8gQ29tbW9uIG91dHB1dHNcbiAgU3VjY2Vzc091dHB1dCxcbiAgRmFpbGVkT3V0cHV0LFxuICBBcHByb3ZhbFJlcXVpcmVkT3V0cHV0LFxuICAvLyBDb21iaW5lZCBvdXRwdXQgdHlwZVxuICBTdGVwT3V0cHV0LFxuICAvLyBPdXRwdXQgc2NoZW1hcyBmb3IgdmFsaWRhdGlvblxuICBQcmVwYXJlT3V0cHV0U2NoZW1hLFxuICBSdW5PdXRwdXRTY2hlbWEsXG4gIFRyaWdnZXJPdXRwdXRTY2hlbWEsXG4gIFBvbGxPdXRwdXRTY2hlbWEsXG4gIFN0ZXBPdXRwdXRTY2hlbWEsXG4gIC8vIEhlbHBlciBmdW5jdGlvbnNcbiAgU3RlcE91dHB1dHMsXG59IGZyb20gXCIuL291dHB1dC9zdGVwLW91dHB1dFwiO1xuXG4vLyBSZWdpc3RyeSBmb3IgcnVubmluZyBzdGVwc1xuZXhwb3J0IHsgU3RlcFJlZ2lzdHJ5LCBTdGVwUmVnaXN0cnlJbnB1dCwgU3RlcFJlZ2lzdHJ5SW5wdXRTY2hlbWEgfSBmcm9tIFwiLi9yZWdpc3RyeS9zdGVwLXJlZ2lzdHJ5XCI7XG5cbi8vIExvZ2dpbmdcbmV4cG9ydCB7IFN0ZXBMb2dnZXIsIFN0ZXBMb2dnZXJDb25maWcsIExvZ0VudHJ5LCBMb2dMZXZlbCB9IGZyb20gXCIuL2xvZ2dpbmcvc3RlcC1sb2dnZXJcIjtcbiJdfQ==

package/dist/registry/step-registry.d.ts

@@ -1,5 +1,5 @@
 import z from "zod";
-import type { StepClass } from "../base/base-step";
+import type { BaseStep } from "../base/base-step";
 export declare const StepRegistryInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     job: z.ZodLiteral<"EXECUTE">;
     type: z.ZodString;
@@ -25,7 +25,10 @@ export declare class StepRegistry {
      *
      * Usage in user's entrypoint file:
      * ```
-     * StepRegistry.run([MyStep1, MyStep2, ...]);
+     * StepRegistry.run([
+     *   new MyStep1(dependency1, dependency2),
+     *   new MyStep2(config)
+     * ]);
      * ```
      *
      * CLI arguments:
@@ -34,7 +37,7 @@ export declare class StepRegistry {
      * - --log-dir: Directory for log files (default: /tmp/step-logs)
      * - --execution-id: Unique ID for this execution (required for logging)
      */
-    static run(steps: StepClass[]): Promise<void>;
+    static run(steps: BaseStep<unknown>[]): Promise<void>;
     private execute;
     private synthesizeMetadata;
     private executeStep;

package/dist/registry/step-registry.js

@@ -79,10 +79,9 @@ class StepRegistry {
         this.outputPath = outputPath;
         this.logDir = logDir;
         this.executionId = executionId;
-        for (const StepCls of steps) {
-            const instance = new StepCls();
+        for (const instance of steps) {
             const metadata = instance.getMetadata();
-            this.steps.set(metadata.stepType, StepCls);
+            this.steps.set(metadata.stepType, instance);
         }
     }
     /**
@@ -91,7 +90,10 @@ class StepRegistry {
      *
      * Usage in user's entrypoint file:
      * ```
-     * StepRegistry.run([MyStep1, MyStep2, ...]);
+     * StepRegistry.run([
+     *   new MyStep1(dependency1, dependency2),
+     *   new MyStep2(config)
+     * ]);
      * ```
      *
      * CLI arguments:
@@ -130,37 +132,35 @@ class StepRegistry {
     }
     synthesizeMetadata() {
         const metadata = [];
-        for (const StepCls of this.steps.values()) {
-            const instance = new StepCls();
+        for (const instance of this.steps.values()) {
             metadata.push(instance.getMetadata());
         }
         return metadata;
     }
     async executeStep(type, params, approvalContext, pollingState) {
-        const StepCls = this.steps.get(type);
-        if (!StepCls) {
+        const instance = this.steps.get(type);
+        if (!instance) {
             this.writeOutput(step_output_1.StepOutputs.failed(`No step registered with type: ${type}`, "STEP_NOT_FOUND"));
             return;
         }
         try {
-            const instance = new StepCls();
-            const metadata = instance.getMetadata();
+            const data = instance.getData();
             // Inject logger
             const logger = new step_logger_1.StepLogger({
                 logDir: this.logDir,
                 executionId: this.executionId,
-                stepType: metadata.stepType,
+                stepType: data.stepType,
             });
             instance._setLogger(logger);
             // Validate params against the step's schema
-            const parseResult = metadata.schema.safeParse(params);
+            const parseResult = data.schema.safeParse(params);
             if (!parseResult.success) {
                 this.writeOutput(step_output_1.StepOutputs.failed(`Invalid params: ${parseResult.error.message}`, "INVALID_PARAMS"));
                 return;
             }
             const validatedParams = parseResult.data;
             // Route to appropriate phase based on step kind and input context
-            const output = await this.routeExecution(instance, metadata, validatedParams, approvalContext, pollingState);
+            const output = await this.routeExecution(instance, data, validatedParams, approvalContext, pollingState);
             this.writeOutput(output);
         }
         catch (error) {
@@ -168,15 +168,15 @@ class StepRegistry {
             this.writeOutput(step_output_1.StepOutputs.failed(errorMessage, "EXECUTION_ERROR"));
         }
     }
-    async routeExecution(instance, metadata, params, approvalContext, pollingState) {
-        const requiresApproval = metadata.requiresApproval;
-        if (metadata.stepKind === "simple") {
+    async routeExecution(instance, data, params, approvalContext, pollingState) {
+        const requiresApproval = data.requiresApproval;
+        if (data.stepKind === "simple") {
             return this.routeSimpleStep(instance, params, requiresApproval, approvalContext);
         }
-        if (metadata.stepKind === "polling") {
+        if (data.stepKind === "polling") {
             return this.routePollingStep(instance, params, requiresApproval, approvalContext, pollingState);
         }
-        return step_output_1.StepOutputs.failed(`Unknown step kind: ${metadata.stepKind}`, "UNKNOWN_STEP_KIND");
+        return step_output_1.StepOutputs.failed(`Unknown step kind: ${data.stepKind}`, "UNKNOWN_STEP_KIND");
     }
     /**
      * Route SimpleStep execution based on approval state.
@@ -235,4 +235,4 @@ class StepRegistry {
     }
 }
 exports.StepRegistry = StepRegistry;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"step-registry.js","sourceRoot":"","sources":["../../src/registry/step-registry.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fs from \"fs\";\nimport * as path from \"path\";\nimport minimist from \"minimist\";\nimport z from \"zod\";\nimport type { BaseStep, StepClass, StepMetadata } from \"../base/base-step\";\nimport type { SimpleStep } from \"../base/simple-step\";\nimport type { PollingStep } from \"../base/polling-step\";\nimport { StepLogger } from \"../logging/step-logger\";\nimport type { ApprovalContext, StepOutput } from \"../output/step-output\";\nimport { ApprovalContextSchema, StepOutputs } from \"../output/step-output\";\n\n// =============================================================================\n// Input Schemas\n// =============================================================================\n\nconst StepRegistrySynthesizeSchema = z.object({\n  job: z.literal(\"SYNTHESIZE-METADATA\"),\n});\n\nconst StepRegistryExecuteSchema = z.object({\n  job: z.literal(\"EXECUTE\"),\n  type: z.string(),\n  params: z.record(z.string(), z.any()),\n  // Optional context - presence determines which phase to run\n  approvalContext: ApprovalContextSchema.optional(),\n  pollingState: z.record(z.string(), z.any()).optional(),\n});\n\nexport const StepRegistryInputSchema = z.discriminatedUnion(\"job\", [\n  StepRegistryExecuteSchema,\n  StepRegistrySynthesizeSchema,\n]);\n\nexport type StepRegistryInput = z.infer<typeof StepRegistryInputSchema>;\n\n// =============================================================================\n// Configuration\n// =============================================================================\n\nconst DEFAULT_OUTPUT_PATH = \"/tmp/step-output.json\";\nconst DEFAULT_LOG_DIR = \"/tmp/step-logs\";\n\n// =============================================================================\n// StepRegistry\n// =============================================================================\n\nexport class StepRegistry {\n  private steps: Map<string, StepClass>;\n  private outputPath: string;\n  private logDir: string;\n  private executionId: string;\n\n  private constructor(\n    steps: StepClass[],\n    outputPath: string,\n    logDir: string,\n    executionId: string\n  ) {\n    this.steps = new Map();\n    this.outputPath = outputPath;\n    this.logDir = logDir;\n    this.executionId = executionId;\n\n    for (const StepCls of steps) {\n      const instance = new StepCls();\n      const metadata = instance.getMetadata();\n      this.steps.set(metadata.stepType, StepCls);\n    }\n  }\n\n  /**\n   * Main entrypoint for running steps.\n   * Parses CLI args and either synthesizes metadata or executes a step.\n   *\n   * Usage in user's entrypoint file:\n   * ```\n   * StepRegistry.run([MyStep1, MyStep2, ...]);\n   * ```\n   *\n   * CLI arguments:\n   * - --input: JSON blob with job type and parameters\n   * - --output: Path to write output JSON (default: /tmp/step-output.json)\n   * - --log-dir: Directory for log files (default: /tmp/step-logs)\n   * - --execution-id: Unique ID for this execution (required for logging)\n   */\n  static async run(steps: StepClass[]): Promise<void> {\n    const args = minimist(process.argv.slice(2));\n    const outputPath = args[\"output\"] || DEFAULT_OUTPUT_PATH;\n    const logDir = args[\"log-dir\"] || DEFAULT_LOG_DIR;\n    const executionId = args[\"execution-id\"] || `exec-${Date.now()}`;\n\n    const registry = new StepRegistry(steps, outputPath, logDir, executionId);\n    await registry.execute(args);\n  }\n\n  private async execute(args: minimist.ParsedArgs): Promise<void> {\n    try {\n      const input = StepRegistryInputSchema.parse(JSON.parse(args[\"input\"]));\n\n      switch (input.job) {\n        case \"SYNTHESIZE-METADATA\": {\n          const metadata = this.synthesizeMetadata();\n          this.writeOutput({ status: \"SUCCESS\", data: { metadata } });\n          break;\n        }\n\n        case \"EXECUTE\": {\n          await this.executeStep(\n            input.type,\n            input.params,\n            input.approvalContext,\n            input.pollingState\n          );\n          break;\n        }\n      }\n    } catch (error) {\n      const errorMessage =\n        error instanceof Error ? error.message : String(error);\n      this.writeOutput(StepOutputs.failed(errorMessage, \"REGISTRY_ERROR\"));\n    }\n  }\n\n  private synthesizeMetadata(): StepMetadata[] {\n    const metadata: StepMetadata[] = [];\n\n    for (const StepCls of this.steps.values()) {\n      const instance = new StepCls();\n      metadata.push(instance.getMetadata());\n    }\n\n    return metadata;\n  }\n\n  private async executeStep(\n    type: string,\n    params: Record<string, unknown>,\n    approvalContext?: ApprovalContext,\n    pollingState?: Record<string, unknown>\n  ): Promise<void> {\n    const StepCls = this.steps.get(type);\n\n    if (!StepCls) {\n      this.writeOutput(\n        StepOutputs.failed(\n          `No step registered with type: ${type}`,\n          \"STEP_NOT_FOUND\"\n        )\n      );\n      return;\n    }\n\n    try {\n      const instance = new StepCls();\n      const metadata = instance.getMetadata();\n\n      // Inject logger\n      const logger = new StepLogger({\n        logDir: this.logDir,\n        executionId: this.executionId,\n        stepType: metadata.stepType,\n      });\n      instance._setLogger(logger);\n\n      // Validate params against the step's schema\n      const parseResult = metadata.schema.safeParse(params);\n      if (!parseResult.success) {\n        this.writeOutput(\n          StepOutputs.failed(\n            `Invalid params: ${parseResult.error.message}`,\n            \"INVALID_PARAMS\"\n          )\n        );\n        return;\n      }\n\n      const validatedParams = parseResult.data;\n\n      // Route to appropriate phase based on step kind and input context\n      const output = await this.routeExecution(\n        instance,\n        metadata,\n        validatedParams,\n        approvalContext,\n        pollingState\n      );\n\n      this.writeOutput(output);\n    } catch (error) {\n      const errorMessage =\n        error instanceof Error ? error.message : String(error);\n      this.writeOutput(StepOutputs.failed(errorMessage, \"EXECUTION_ERROR\"));\n    }\n  }\n\n  private async routeExecution(\n    instance: BaseStep<unknown>,\n    metadata: StepMetadata,\n    params: unknown,\n    approvalContext?: ApprovalContext,\n    pollingState?: Record<string, unknown>\n  ): Promise<StepOutput> {\n    const requiresApproval = metadata.requiresApproval;\n\n    if (metadata.stepKind === \"simple\") {\n      return this.routeSimpleStep(\n        instance as SimpleStep<unknown>,\n        params,\n        requiresApproval,\n        approvalContext\n      );\n    }\n\n    if (metadata.stepKind === \"polling\") {\n      return this.routePollingStep(\n        instance as PollingStep<unknown, Record<string, unknown>>,\n        params,\n        requiresApproval,\n        approvalContext,\n        pollingState\n      );\n    }\n\n    return StepOutputs.failed(\n      `Unknown step kind: ${metadata.stepKind}`,\n      \"UNKNOWN_STEP_KIND\"\n    );\n  }\n\n  /**\n   * Route SimpleStep execution based on approval state.\n   *\n   * | requiresApproval | approvalContext provided? | Action              |\n   * |------------------|---------------------------|---------------------|\n   * | No               | -                         | Call run(params)    |\n   * | Yes              | No                        | Call prepare(params)|\n   * | Yes              | Yes                       | Call run(params, approval) |\n   */\n  private async routeSimpleStep(\n    instance: SimpleStep<unknown>,\n    params: unknown,\n    requiresApproval: boolean,\n    approvalContext?: ApprovalContext\n  ): Promise<StepOutput> {\n    if (!requiresApproval) {\n      // No approval needed - just run\n      return instance.execute(params, undefined);\n    }\n\n    if (!approvalContext) {\n      // Needs approval but don't have it yet - call prepare\n      return instance.prepare(params);\n    }\n\n    // Have approval - run with approval context\n    return instance.execute(params, approvalContext);\n  }\n\n  /**\n   * Route PollingStep execution based on approval and polling state.\n   *\n   * | requiresApproval | approvalContext? | pollingState? | Action                        |\n   * |------------------|------------------|---------------|-------------------------------|\n   * | No               | -                | No            | Call trigger(params)          |\n   * | No               | -                | Yes           | Call poll(params, pollingState)|\n   * | Yes              | No               | No            | Call prepare(params)          |\n   * | Yes              | Yes              | No            | Call trigger(params, approval)|\n   * | Yes              | Yes              | Yes           | Call poll(params, pollingState)|\n   */\n  private async routePollingStep(\n    instance: PollingStep<unknown, Record<string, unknown>>,\n    params: unknown,\n    requiresApproval: boolean,\n    approvalContext?: ApprovalContext,\n    pollingState?: Record<string, unknown>\n  ): Promise<StepOutput> {\n    // If we have polling state, we're in the poll phase (regardless of approval)\n    if (pollingState) {\n      return instance.executePoll(params, pollingState);\n    }\n\n    if (!requiresApproval) {\n      // No approval needed - trigger directly\n      return instance.executeTrigger(params, undefined);\n    }\n\n    if (!approvalContext) {\n      // Needs approval but don't have it yet - call prepare\n      return instance.prepare(params);\n    }\n\n    // Have approval - trigger with approval context\n    return instance.executeTrigger(params, approvalContext);\n  }\n\n  private writeOutput(output: StepOutput): void {\n    const outputDir = path.dirname(this.outputPath);\n    if (!fs.existsSync(outputDir)) {\n      fs.mkdirSync(outputDir, { recursive: true });\n    }\n\n    fs.writeFileSync(this.outputPath, JSON.stringify(output, null, 2));\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"step-registry.js","sourceRoot":"","sources":["../../src/registry/step-registry.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fs from \"fs\";\nimport * as path from \"path\";\nimport minimist from \"minimist\";\nimport z from \"zod\";\nimport type { BaseStep, StepData, StepMetadata } from \"../base/base-step\";\nimport type { SimpleStep } from \"../base/simple-step\";\nimport type { PollingStep } from \"../base/polling-step\";\nimport { StepLogger } from \"../logging/step-logger\";\nimport type { ApprovalContext, StepOutput } from \"../output/step-output\";\nimport { ApprovalContextSchema, StepOutputs } from \"../output/step-output\";\n\n// =============================================================================\n// Input Schemas\n// =============================================================================\n\nconst StepRegistrySynthesizeSchema = z.object({\n  job: z.literal(\"SYNTHESIZE-METADATA\"),\n});\n\nconst StepRegistryExecuteSchema = z.object({\n  job: z.literal(\"EXECUTE\"),\n  type: z.string(),\n  params: z.record(z.string(), z.any()),\n  // Optional context - presence determines which phase to run\n  approvalContext: ApprovalContextSchema.optional(),\n  pollingState: z.record(z.string(), z.any()).optional(),\n});\n\nexport const StepRegistryInputSchema = z.discriminatedUnion(\"job\", [\n  StepRegistryExecuteSchema,\n  StepRegistrySynthesizeSchema,\n]);\n\nexport type StepRegistryInput = z.infer<typeof StepRegistryInputSchema>;\n\n// =============================================================================\n// Configuration\n// =============================================================================\n\nconst DEFAULT_OUTPUT_PATH = \"/tmp/step-output.json\";\nconst DEFAULT_LOG_DIR = \"/tmp/step-logs\";\n\n// =============================================================================\n// StepRegistry\n// =============================================================================\n\nexport class StepRegistry {\n  private steps: Map<string, BaseStep<unknown>>;\n  private outputPath: string;\n  private logDir: string;\n  private executionId: string;\n\n  private constructor(\n    steps: BaseStep<unknown>[],\n    outputPath: string,\n    logDir: string,\n    executionId: string\n  ) {\n    this.steps = new Map();\n    this.outputPath = outputPath;\n    this.logDir = logDir;\n    this.executionId = executionId;\n\n    for (const instance of steps) {\n      const metadata = instance.getMetadata();\n      this.steps.set(metadata.stepType, instance);\n    }\n  }\n\n  /**\n   * Main entrypoint for running steps.\n   * Parses CLI args and either synthesizes metadata or executes a step.\n   *\n   * Usage in user's entrypoint file:\n   * ```\n   * StepRegistry.run([\n   *   new MyStep1(dependency1, dependency2),\n   *   new MyStep2(config)\n   * ]);\n   * ```\n   *\n   * CLI arguments:\n   * - --input: JSON blob with job type and parameters\n   * - --output: Path to write output JSON (default: /tmp/step-output.json)\n   * - --log-dir: Directory for log files (default: /tmp/step-logs)\n   * - --execution-id: Unique ID for this execution (required for logging)\n   */\n  static async run(steps: BaseStep<unknown>[]): Promise<void> {\n    const args = minimist(process.argv.slice(2));\n    const outputPath = args[\"output\"] || DEFAULT_OUTPUT_PATH;\n    const logDir = args[\"log-dir\"] || DEFAULT_LOG_DIR;\n    const executionId = args[\"execution-id\"] || `exec-${Date.now()}`;\n\n    const registry = new StepRegistry(steps, outputPath, logDir, executionId);\n    await registry.execute(args);\n  }\n\n  private async execute(args: minimist.ParsedArgs): Promise<void> {\n    try {\n      const input = StepRegistryInputSchema.parse(JSON.parse(args[\"input\"]));\n\n      switch (input.job) {\n        case \"SYNTHESIZE-METADATA\": {\n          const metadata = this.synthesizeMetadata();\n          this.writeOutput({ status: \"SUCCESS\", data: { metadata } });\n          break;\n        }\n\n        case \"EXECUTE\": {\n          await this.executeStep(\n            input.type,\n            input.params,\n            input.approvalContext,\n            input.pollingState\n          );\n          break;\n        }\n      }\n    } catch (error) {\n      const errorMessage =\n        error instanceof Error ? error.message : String(error);\n      this.writeOutput(StepOutputs.failed(errorMessage, \"REGISTRY_ERROR\"));\n    }\n  }\n\n  private synthesizeMetadata(): StepMetadata[] {\n    const metadata: StepMetadata[] = [];\n\n    for (const instance of this.steps.values()) {\n      metadata.push(instance.getMetadata());\n    }\n\n    return metadata;\n  }\n\n  private async executeStep(\n    type: string,\n    params: Record<string, unknown>,\n    approvalContext?: ApprovalContext,\n    pollingState?: Record<string, unknown>\n  ): Promise<void> {\n    const instance = this.steps.get(type);\n\n    if (!instance) {\n      this.writeOutput(\n        StepOutputs.failed(\n          `No step registered with type: ${type}`,\n          \"STEP_NOT_FOUND\"\n        )\n      );\n      return;\n    }\n\n    try {\n      const data = instance.getData();\n\n      // Inject logger\n      const logger = new StepLogger({\n        logDir: this.logDir,\n        executionId: this.executionId,\n        stepType: data.stepType,\n      });\n      instance._setLogger(logger);\n\n      // Validate params against the step's schema\n      const parseResult = data.schema.safeParse(params);\n      if (!parseResult.success) {\n        this.writeOutput(\n          StepOutputs.failed(\n            `Invalid params: ${parseResult.error.message}`,\n            \"INVALID_PARAMS\"\n          )\n        );\n        return;\n      }\n\n      const validatedParams = parseResult.data;\n\n      // Route to appropriate phase based on step kind and input context\n      const output = await this.routeExecution(\n        instance,\n        data,\n        validatedParams,\n        approvalContext,\n        pollingState\n      );\n\n      this.writeOutput(output);\n    } catch (error) {\n      const errorMessage =\n        error instanceof Error ? error.message : String(error);\n      this.writeOutput(StepOutputs.failed(errorMessage, \"EXECUTION_ERROR\"));\n    }\n  }\n\n  private async routeExecution(\n    instance: BaseStep<unknown>,\n    data: StepData,\n    params: unknown,\n    approvalContext?: ApprovalContext,\n    pollingState?: Record<string, unknown>\n  ): Promise<StepOutput> {\n    const requiresApproval = data.requiresApproval;\n\n    if (data.stepKind === \"simple\") {\n      return this.routeSimpleStep(\n        instance as SimpleStep<unknown>,\n        params,\n        requiresApproval,\n        approvalContext\n      );\n    }\n\n    if (data.stepKind === \"polling\") {\n      return this.routePollingStep(\n        instance as PollingStep<unknown, Record<string, unknown>>,\n        params,\n        requiresApproval,\n        approvalContext,\n        pollingState\n      );\n    }\n\n    return StepOutputs.failed(\n      `Unknown step kind: ${data.stepKind}`,\n      \"UNKNOWN_STEP_KIND\"\n    );\n  }\n\n  /**\n   * Route SimpleStep execution based on approval state.\n   *\n   * | requiresApproval | approvalContext provided? | Action              |\n   * |------------------|---------------------------|---------------------|\n   * | No               | -                         | Call run(params)    |\n   * | Yes              | No                        | Call prepare(params)|\n   * | Yes              | Yes                       | Call run(params, approval) |\n   */\n  private async routeSimpleStep(\n    instance: SimpleStep<unknown>,\n    params: unknown,\n    requiresApproval: boolean,\n    approvalContext?: ApprovalContext\n  ): Promise<StepOutput> {\n    if (!requiresApproval) {\n      // No approval needed - just run\n      return instance.execute(params, undefined);\n    }\n\n    if (!approvalContext) {\n      // Needs approval but don't have it yet - call prepare\n      return instance.prepare(params);\n    }\n\n    // Have approval - run with approval context\n    return instance.execute(params, approvalContext);\n  }\n\n  /**\n   * Route PollingStep execution based on approval and polling state.\n   *\n   * | requiresApproval | approvalContext? | pollingState? | Action                        |\n   * |------------------|------------------|---------------|-------------------------------|\n   * | No               | -                | No            | Call trigger(params)          |\n   * | No               | -                | Yes           | Call poll(params, pollingState)|\n   * | Yes              | No               | No            | Call prepare(params)          |\n   * | Yes              | Yes              | No            | Call trigger(params, approval)|\n   * | Yes              | Yes              | Yes           | Call poll(params, pollingState)|\n   */\n  private async routePollingStep(\n    instance: PollingStep<unknown, Record<string, unknown>>,\n    params: unknown,\n    requiresApproval: boolean,\n    approvalContext?: ApprovalContext,\n    pollingState?: Record<string, unknown>\n  ): Promise<StepOutput> {\n    // If we have polling state, we're in the poll phase (regardless of approval)\n    if (pollingState) {\n      return instance.executePoll(params, pollingState);\n    }\n\n    if (!requiresApproval) {\n      // No approval needed - trigger directly\n      return instance.executeTrigger(params, undefined);\n    }\n\n    if (!approvalContext) {\n      // Needs approval but don't have it yet - call prepare\n      return instance.prepare(params);\n    }\n\n    // Have approval - trigger with approval context\n    return instance.executeTrigger(params, approvalContext);\n  }\n\n  private writeOutput(output: StepOutput): void {\n    const outputDir = path.dirname(this.outputPath);\n    if (!fs.existsSync(outputDir)) {\n      fs.mkdirSync(outputDir, { recursive: true });\n    }\n\n    fs.writeFileSync(this.outputPath, JSON.stringify(output, null, 2));\n  }\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devramps/sdk-typescript",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "SDK for building custom deployment steps for DevRamps",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -10,6 +10,9 @@
     "LICENSE",
     "README.md"
   ],
+  "bin": {
+    "create-step-registry": "./scripts/create-step-registry.js"
+  },
   "exports": {
     ".": {
       "import": "./dist/index.js",

package/scripts/create-step-registry.js

@@ -0,0 +1,300 @@
+#!/usr/bin/env node
+
+const fs = require("fs");
+const path = require("path");
+const { execSync } = require("child_process");
+
+// Get optional folder name from command line args, default to "step-registry"
+const folderName = process.argv[3] || "step-registry";
+
+// Define the base directory
+const baseDir = path.join(process.cwd(), folderName);
+
+// Create the folder
+console.log(`Creating ${folderName} folder...`);
+if (!fs.existsSync(baseDir)) {
+  fs.mkdirSync(baseDir);
+}
+
+// Initialize NPM project
+console.log("Initializing NPM project...");
+execSync("npm init -y", { cwd: baseDir, stdio: "inherit" });
+
+// Install dependencies
+console.log("Installing dependencies...");
+execSync("npm install @devramps/sdk-typescript zod", {
+  cwd: baseDir,
+  stdio: "inherit",
+});
+execSync("npm install --save-dev @types/node jest ts-jest @types/jest", {
+  cwd: baseDir,
+  stdio: "inherit",
+});
+
+// Create src folder structure
+const srcDir = path.join(baseDir, "src");
+const stepsDir = path.join(srcDir, "steps");
+console.log("Creating src/steps folder structure...");
+if (!fs.existsSync(srcDir)) {
+  fs.mkdirSync(srcDir);
+}
+if (!fs.existsSync(stepsDir)) {
+  fs.mkdirSync(stepsDir, { recursive: true });
+}
+
+// Create tst folder structure
+const tstDir = path.join(baseDir, "tst");
+const tstStepsDir = path.join(tstDir, "steps");
+console.log("Creating tst/steps folder structure...");
+if (!fs.existsSync(tstDir)) {
+  fs.mkdirSync(tstDir);
+}
+if (!fs.existsSync(tstStepsDir)) {
+  fs.mkdirSync(tstStepsDir, { recursive: true });
+}
+
+// Create deployment-service.ts (dependency example)
+console.log("Creating deployment-service.ts...");
+const deploymentServiceContent = `export interface DeploymentService {
+  deploy(target: string, version?: string): Promise<{ deploymentId: string }>;
+}
+
+export class RealDeploymentService implements DeploymentService {
+  async deploy(target: string, version?: string): Promise<{ deploymentId: string }> {
+    // Simulate a deployment
+    console.log(\`Deploying to \${target}\${version ? \` version \${version}\` : ""}\`);
+    return { deploymentId: \`deploy-\${Date.now()}\` };
+  }
+}
+`;
+fs.writeFileSync(
+  path.join(srcDir, "deployment-service.ts"),
+  deploymentServiceContent
+);
+
+// Create my-first-step.ts
+console.log("Creating my-first-step.ts...");
+const myFirstStepContent = `import {
+  RunOutput,
+  SimpleStep,
+  Step,
+  StepOutputs,
+} from "@devramps/sdk-typescript";
+import z from "zod";
+import { DeploymentService } from "../deployment-service";
+
+const DeploySchema = z.object({
+  target: z.string().describe("A Target"),
+  version: z.string().optional(),
+});
+
+type DeployParams = z.infer<typeof DeploySchema>;
+
+@Step({
+  name: "Custom Deployment Action",
+  type: "CUSTOM:SCRIPT:DEPLOY",
+  schema: DeploySchema,
+})
+export class MyFirstStep extends SimpleStep<DeployParams> {
+  constructor(private deploymentService: DeploymentService) {
+    super();
+  }
+
+  async run(params: DeployParams): Promise<RunOutput> {
+    this.logger.info(\`Deploying with params: \${JSON.stringify(params)}\`);
+
+    const result = await this.deploymentService.deploy(
+      params.target,
+      params.version
+    );
+
+    this.logger.info(\`Deployment completed: \${result.deploymentId}\`);
+
+    return StepOutputs.success({
+      deploymentId: result.deploymentId,
+      target: params.target,
+      version: params.version,
+    });
+  }
+}
+`;
+fs.writeFileSync(path.join(stepsDir, "my-first-step.ts"), myFirstStepContent);
+
+// Create src/index.ts
+console.log("Creating src/index.ts...");
+const indexContent = `import { StepRegistry } from "@devramps/sdk-typescript";
+import { MyFirstStep } from "./steps/my-first-step";
+import { RealDeploymentService } from "./deployment-service";
+
+// Instantiate dependencies
+const deploymentService = new RealDeploymentService();
+
+// Instantiate steps with their dependencies
+const myFirstStep = new MyFirstStep(deploymentService);
+
+// Register step instances
+StepRegistry.run([myFirstStep]);
+`;
+fs.writeFileSync(path.join(srcDir, "index.ts"), indexContent);
+
+// Create tsconfig.json
+console.log("Creating tsconfig.json...");
+const tsconfigContent = `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "lib": ["ES2022"],
+    "types": ["node", "jest"],
+    "declaration": true,
+    "strict": true,
+    "noImplicitAny": true,
+    "strictNullChecks": true,
+    "noImplicitThis": true,
+    "alwaysStrict": true,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": false,
+    "inlineSourceMap": true,
+    "inlineSources": true,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "strictPropertyInitialization": false,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}
+`;
+fs.writeFileSync(path.join(baseDir, "tsconfig.json"), tsconfigContent);
+
+// Create jest.config.js
+console.log("Creating jest.config.js...");
+const jestConfigContent = `module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  roots: ['<rootDir>/tst'],
+  testMatch: ['**/*.test.ts'],
+  moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx', 'json', 'node'],
+  collectCoverageFrom: [
+    'src/**/*.ts',
+    '!src/**/*.d.ts',
+  ],
+};
+`;
+fs.writeFileSync(path.join(baseDir, "jest.config.js"), jestConfigContent);
+
+// Create test file for my-first-step
+console.log("Creating tst/steps/my-first-step.test.ts...");
+const testContent = `import { MyFirstStep } from "../../src/steps/my-first-step";
+import { DeploymentService } from "../../src/deployment-service";
+import { StepOutputs } from "@devramps/sdk-typescript";
+
+// Mock implementation of DeploymentService for testing
+class MockDeploymentService implements DeploymentService {
+  async deploy(target: string, version?: string): Promise<{ deploymentId: string }> {
+    return { deploymentId: \`mock-deploy-\${target}-\${version || "latest"}\` };
+  }
+}
+
+describe("MyFirstStep", () => {
+  let mockDeploymentService: MockDeploymentService;
+  let step: MyFirstStep;
+
+  beforeEach(() => {
+    // Create mock dependency
+    mockDeploymentService = new MockDeploymentService();
+    // Inject mock into step
+    step = new MyFirstStep(mockDeploymentService);
+  });
+
+  it("should run successfully with valid parameters", async () => {
+    const params = {
+      target: "production",
+      version: "1.0.0",
+    };
+
+    const result = await step.run(params);
+
+    expect(result.status).toBe("SUCCESS");
+    if (result.status === "SUCCESS") {
+      expect(result.data).toEqual({
+        deploymentId: "mock-deploy-production-1.0.0",
+        target: "production",
+        version: "1.0.0",
+      });
+    }
+  });
+
+  it("should run successfully without optional version parameter", async () => {
+    const params = {
+      target: "staging",
+    };
+
+    const result = await step.run(params);
+
+    expect(result.status).toBe("SUCCESS");
+    if (result.status === "SUCCESS") {
+      expect(result.data).toEqual({
+        deploymentId: "mock-deploy-staging-latest",
+        target: "staging",
+        version: undefined,
+      });
+    }
+  });
+
+  it("should call deployment service with correct parameters", async () => {
+    const deploySpy = jest.spyOn(mockDeploymentService, "deploy");
+    const params = {
+      target: "development",
+      version: "2.0.0",
+    };
+
+    await step.run(params);
+
+    expect(deploySpy).toHaveBeenCalledWith("development", "2.0.0");
+  });
+
+  it("should log deployment information", async () => {
+    // Access the logger through type assertion to test logging behavior
+    const logSpy = jest.spyOn((step as any).logger, "info");
+    const params = {
+      target: "production",
+      version: "3.0.0",
+    };
+
+    await step.run(params);
+
+    expect(logSpy).toHaveBeenCalledWith(
+      \`Deploying with params: \${JSON.stringify(params)}\`
+    );
+    expect(logSpy).toHaveBeenCalledWith(
+      "Deployment completed: mock-deploy-production-3.0.0"
+    );
+  });
+});
+`;
+fs.writeFileSync(path.join(tstStepsDir, "my-first-step.test.ts"), testContent);
+
+// Update package.json to add build and start scripts
+console.log("Adding build and start scripts to package.json...");
+const packageJsonPath = path.join(baseDir, "package.json");
+const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+packageJson.scripts = {
+  ...packageJson.scripts,
+  "build-step-registry": "tsc -p tsconfig.json",
+  "start-step-registry": "node ./dist/index.js",
+  test: "jest",
+  "test:watch": "jest --watch",
+  "test:coverage": "jest --coverage",
+};
+fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+
+console.log(`\nStep registry created successfully in '${folderName}'!`);
+console.log(`\nNext steps:`);
+console.log(`  cd ${folderName}`);
+console.log(`  npm run build-step-registry`);
+console.log(`  npm run test`);