@project-ajax/sdk 0.0.28

package/dist/cli/commands/auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/auth.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,YAAY,wEAwEvB,CAAC"}

package/dist/cli/commands/auth.impl.d.ts

@@ -0,0 +1,10 @@
+import type { Environment } from "../config.js";
+interface LoginFlags {
+    env?: Environment;
+    "base-url"?: string;
+}
+export declare const login: (this: import("../context.js").LocalContext, flags: import("../flags.js").GlobalFlags & LoginFlags, token?: string | undefined) => Promise<void>;
+export declare const show: (this: import("../context.js").LocalContext, flags: import("../flags.js").GlobalFlags) => Promise<void>;
+export declare const logout: (this: import("../context.js").LocalContext, flags: import("../flags.js").GlobalFlags) => Promise<void>;
+export {};
+//# sourceMappingURL=auth.impl.d.ts.map

package/dist/cli/commands/auth.impl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.impl.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/auth.impl.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAGhD,UAAU,UAAU;IACnB,GAAG,CAAC,EAAE,WAAW,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;CACpB;AAqCD,eAAO,MAAM,KAAK,kJAqChB,CAAC;AAEH,eAAO,MAAM,IAAI,yGAEf,CAAC;AAEH,eAAO,MAAM,MAAM,yGAEjB,CAAC"}

package/dist/cli/commands/auth.impl.js

@@ -0,0 +1,68 @@
+import { exec } from "node:child_process";
+import { existsSync } from "node:fs";
+import { baseUrl } from "../api/client.js";
+import { buildHandler } from "../handler.js";
+async function openUrl(env, url) {
+  const platform = process.platform;
+  try {
+    if (platform === "darwin") {
+      let notionAppName = null;
+      if (env === "prod" && existsSync("/Applications/Notion.app")) {
+        notionAppName = "Notion";
+      } else if (env === "dev" && existsSync("/Applications/Notion Dev.app")) {
+        notionAppName = "Notion Dev";
+      }
+      if (notionAppName) {
+        exec(`open -a "${notionAppName}" "${url}"`);
+      } else {
+        exec(`open "${url}"`);
+      }
+    } else if (platform === "win32") {
+      exec(`start "" "${url}"`);
+    } else {
+      exec(`xdg-open "${url}"`);
+    }
+  } catch (error) {
+    throw new Error(`Failed to open browser: ${error}`);
+  }
+}
+const login = buildHandler(async function(flags, token) {
+  const environment = flags.env ?? "prod";
+  if (flags["base-url"]) {
+    await this.config.setBaseUrl(flags["base-url"]);
+  }
+  if (!token) {
+    const url = `${baseUrl({
+      environment,
+      override: this.config.baseUrl
+    })}/__workers__?createToken=true`;
+    this.writer.writeErr(`Opening browser to create a token...
+${url}
+`);
+    this.writer.writeErr("After creating a token, run:");
+    this.writer.writeErr("	npx workers auth login <token>");
+    try {
+      await openUrl(environment, url);
+    } catch (_error) {
+      this.writer.writeErr(
+        `Failed to open browser automatically. Please visit:
+  ${url}`
+      );
+    }
+    return;
+  }
+  await this.config.setEnvironment(environment);
+  await this.config.setToken(token);
+  this.writer.writeErr("Successfully logged in!");
+});
+const show = buildHandler(function() {
+  this.writer.writeOut(`${this.config.token ?? ""}`);
+});
+const logout = buildHandler(async function() {
+  await this.config.setToken(null);
+});
+export {
+  login,
+  logout,
+  show
+};

package/dist/cli/commands/auth.js

@@ -0,0 +1,71 @@
+import { buildCommand, buildRouteMap } from "@stricli/core";
+import { Environments } from "../config.js";
+import { globalFlags } from "../flags.js";
+const authCommands = buildRouteMap({
+  docs: {
+    brief: "Commands for managing the CLI context"
+  },
+  routes: {
+    login: buildCommand({
+      docs: {
+        brief: "Login to the Project Ajax platform using a Workers API token"
+      },
+      parameters: {
+        positional: {
+          kind: "tuple",
+          parameters: [
+            {
+              brief: "A Workers API token",
+              parse: String,
+              placeholder: "api-token",
+              optional: true
+            }
+          ]
+        },
+        flags: {
+          env: {
+            kind: "enum",
+            values: Environments,
+            brief: "The environment to use for the command",
+            optional: true,
+            hidden: true
+          },
+          "base-url": {
+            kind: "parsed",
+            parse: String,
+            brief: "The base URL to use for all API requests",
+            optional: true,
+            hidden: true
+          },
+          ...globalFlags
+        }
+      },
+      loader: () => import("./auth.impl.js").then((m) => m.login)
+    }),
+    show: buildCommand({
+      docs: {
+        brief: "Get the token for the CLI"
+      },
+      parameters: {
+        flags: {
+          ...globalFlags
+        }
+      },
+      loader: () => import("./auth.impl.js").then((m) => m.show)
+    }),
+    logout: buildCommand({
+      docs: {
+        brief: "Unset the token for the CLI"
+      },
+      parameters: {
+        flags: {
+          ...globalFlags
+        }
+      },
+      loader: () => import("./auth.impl.js").then((m) => m.logout)
+    })
+  }
+});
+export {
+  authCommands
+};

package/dist/cli/commands/bundle.d.ts

@@ -0,0 +1,2 @@
+export declare const bundleCommands: import("@stricli/core").RouteMap<import("../context.js").LocalContext>;
+//# sourceMappingURL=bundle.d.ts.map

package/dist/cli/commands/bundle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundle.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/bundle.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,cAAc,wEAmBzB,CAAC"}

package/dist/cli/commands/bundle.impl.d.ts

@@ -0,0 +1,2 @@
+export declare const downloadBundle: (this: import("../context.js").LocalContext, flags: import("../flags.js").GlobalFlags) => Promise<void>;
+//# sourceMappingURL=bundle.impl.d.ts.map

package/dist/cli/commands/bundle.impl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundle.impl.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/bundle.impl.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,cAAc,yGAgBzB,CAAC"}

package/dist/cli/commands/bundle.impl.js

@@ -0,0 +1,21 @@
+import { Readable } from "node:stream";
+import { Result } from "../api/result.js";
+import { buildAuthedHandler } from "../handler.js";
+const downloadBundle = buildAuthedHandler(async function() {
+  const { workerId } = this.config;
+  if (!workerId) {
+    throw new Error(
+      "No worker configured. Run 'workers deploy' first to create a worker."
+    );
+  }
+  const result = await this.apiClient.downloadWorkerBundle(workerId);
+  if (Result.isFail(result)) {
+    this.writer.writeErr(`\u2717 Failed to download bundle`);
+    this.writer.writeErr(`\u2717 ${result.error.message}`);
+    return;
+  }
+  Readable.fromWeb(result.value).pipe(this.process.stdout);
+});
+export {
+  downloadBundle
+};

package/dist/cli/commands/bundle.js

@@ -0,0 +1,23 @@
+import { buildCommand, buildRouteMap } from "@stricli/core";
+import { globalFlags } from "../flags.js";
+const bundleCommands = buildRouteMap({
+  docs: {
+    brief: "Commands for managing worker bundles"
+  },
+  routes: {
+    download: buildCommand({
+      docs: {
+        brief: "Download the bundle for the worker"
+      },
+      parameters: {
+        flags: {
+          ...globalFlags
+        }
+      },
+      loader: () => import("./bundle.impl.js").then((m) => m.downloadBundle)
+    })
+  }
+});
+export {
+  bundleCommands
+};

package/dist/cli/commands/capabilities.d.ts

@@ -0,0 +1,2 @@
+export declare const capabilitiesCommands: import("@stricli/core").RouteMap<import("../context.js").LocalContext>;
+//# sourceMappingURL=capabilities.d.ts.map

package/dist/cli/commands/capabilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capabilities.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/capabilities.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,oBAAoB,wEAqB/B,CAAC"}

package/dist/cli/commands/capabilities.impl.d.ts

@@ -0,0 +1,3 @@
+import type { FormatFlags } from "../flags.js";
+export declare const listCapabilities: (this: import("../context.js").LocalContext, flags: import("../flags.js").GlobalFlags & FormatFlags) => Promise<void>;
+//# sourceMappingURL=capabilities.impl.d.ts.map

package/dist/cli/commands/capabilities.impl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capabilities.impl.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/capabilities.impl.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAG/C,eAAO,MAAM,gBAAgB,uHA0C3B,CAAC"}

package/dist/cli/commands/capabilities.impl.js

@@ -0,0 +1,40 @@
+import { Result } from "../api/result.js";
+import { buildAuthedHandler } from "../handler.js";
+const listCapabilities = buildAuthedHandler(async function(flags) {
+  const { workerId } = this.config;
+  if (!workerId) {
+    throw new Error(
+      "No worker configured. Run 'workers deploy' first to create a worker."
+    );
+  }
+  this.process.stderr.write(`Fetching capabilities...`);
+  const result = await this.apiClient.listCapabilities(workerId);
+  if (Result.isSuccess(result)) {
+    this.process.stderr.write("OK\n\n");
+    const data = Result.unwrap(result);
+    if (data.capabilities.length === 0) {
+      this.writer.writeErr("No capabilities found for this worker.");
+    } else {
+      this.writer.writeTableOut({
+        headers: ["Key", "Tag"],
+        rows: data.capabilities.map((capability) => [
+          capability.key,
+          capability._tag
+        ]),
+        plain: flags.plain
+      });
+    }
+  } else {
+    this.process.stderr.write("ERROR\n\n");
+    if (result.error.validationError) {
+      this.writer.writeErr(`\u2717 ${result.error.validationError.debugMessage}`);
+      throw new Error(result.error.validationError.debugMessage);
+    } else {
+      this.writer.writeErr(`\u2717 ${result.error.message}`);
+      throw new Error(result.error.message);
+    }
+  }
+});
+export {
+  listCapabilities
+};

package/dist/cli/commands/capabilities.js

@@ -0,0 +1,24 @@
+import { buildCommand, buildRouteMap } from "@stricli/core";
+import { formatFlags, globalFlags } from "../flags.js";
+const capabilitiesCommands = buildRouteMap({
+  docs: {
+    brief: "Commands for managing worker capabilities"
+  },
+  routes: {
+    list: buildCommand({
+      docs: {
+        brief: "List all capabilities for a worker"
+      },
+      parameters: {
+        flags: {
+          ...globalFlags,
+          ...formatFlags
+        }
+      },
+      loader: () => import("./capabilities.impl.js").then((m) => m.listCapabilities)
+    })
+  }
+});
+export {
+  capabilitiesCommands
+};

package/dist/cli/commands/deploy.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("@stricli/core").Command<import("../context.js").LocalContext>;
+export default _default;
+//# sourceMappingURL=deploy.d.ts.map

package/dist/cli/commands/deploy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deploy.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/deploy.ts"],"names":[],"mappings":";AAGA,wBAYG"}

package/dist/cli/commands/deploy.impl.d.ts

@@ -0,0 +1,2 @@
+export declare const deploy: (this: import("../context.js").LocalContext, flags: import("../flags.js").GlobalFlags) => Promise<void>;
+//# sourceMappingURL=deploy.impl.d.ts.map

package/dist/cli/commands/deploy.impl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deploy.impl.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/deploy.impl.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,MAAM,yGA6BjB,CAAC"}

package/dist/cli/commands/deploy.impl.js

@@ -0,0 +1,31 @@
+import { Result } from "../api/result.js";
+import { deployWorker } from "../deploy.js";
+import { buildAuthedHandler } from "../handler.js";
+const deploy = buildAuthedHandler(async function() {
+  const { token } = this.config.tokenInfo;
+  const workerId = this.config.workerId;
+  const environment = this.config.environment;
+  if (!environment) {
+    throw new Error("Unexpected error: Environment not set");
+  }
+  const workerPath = this.process.cwd();
+  this.writer.writeErr("Deploying worker...");
+  const result = await deployWorker(this, {
+    workerPath,
+    workerId,
+    token,
+    environment
+  });
+  if (Result.isSuccess(result)) {
+    const { workerId: workerId2 } = Result.unwrap(result);
+    await this.config.setWorkerId(workerId2);
+    this.writer.writeErr("\u2713 Successfully deployed worker");
+  } else {
+    this.writer.writeErr("\u2717 Failed to deploy worker");
+    this.writer.writeErr(result.error.message);
+    return;
+  }
+});
+export {
+  deploy
+};

package/dist/cli/commands/deploy.js

@@ -0,0 +1,16 @@
+import { buildCommand } from "@stricli/core";
+import { globalFlags } from "../flags.js";
+var deploy_default = buildCommand({
+  docs: {
+    brief: "Deploy a worker to the Project Ajax platform"
+  },
+  parameters: {
+    flags: {
+      ...globalFlags
+    }
+  },
+  loader: () => import("./deploy.impl.js").then((m) => m.deploy)
+});
+export {
+  deploy_default as default
+};

package/dist/cli/commands/exec.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("@stricli/core").Command<import("../context.js").LocalContext>;
+export default _default;
+//# sourceMappingURL=exec.d.ts.map

package/dist/cli/commands/exec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exec.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/exec.ts"],"names":[],"mappings":";AAGA,wBA4BG"}

package/dist/cli/commands/exec.impl.d.ts

@@ -0,0 +1,7 @@
+import type { GlobalFlags } from "../flags.js";
+interface ExecFlags extends GlobalFlags {
+    stream: boolean;
+}
+export declare const exec: (this: import("../context.js").LocalContext, flags: GlobalFlags & ExecFlags, ...args: readonly string[]) => Promise<void>;
+export {};
+//# sourceMappingURL=exec.impl.d.ts.map

package/dist/cli/commands/exec.impl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exec.impl.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/exec.impl.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAM/C,UAAU,SAAU,SAAQ,WAAW;IACtC,MAAM,EAAE,OAAO,CAAC;CAChB;AAED,eAAO,MAAM,IAAI,2HAyJf,CAAC"}

package/dist/cli/commands/exec.impl.js

@@ -0,0 +1,122 @@
+import { Result } from "../api/result.js";
+import { buildAuthedHandler } from "../handler.js";
+import { chunkEvery } from "../utils/array.js";
+const usageHint = `Usage: workers exec <capabilityName> <capabilityFunction> [<argName1>=<value1> <argName2>=<value2>...]`;
+const exec = buildAuthedHandler(async function(flags, ...args) {
+  const { workerId } = this.config;
+  if (!workerId) {
+    throw new Error(
+      "No worker configured. Run 'workers deploy' first to create a worker."
+    );
+  }
+  const capabilityName = args[0];
+  const capabilityFunction = args[1] ?? null;
+  const functionArgs = args.slice(2).flatMap((arg) => arg.split(/[=]/));
+  if (!capabilityName) {
+    throw usageError();
+  }
+  if (functionArgs.length % 2 !== 0) {
+    throw usageError();
+  }
+  const argsList = chunkEvery(functionArgs, 2).map(([key, value]) => {
+    if (!key || !value) {
+      throw usageError();
+    }
+    return {
+      name: key,
+      value
+    };
+  });
+  this.writer.writeErr(`Executing capability "${capabilityName}"...`);
+  if (flags.stream) {
+    const result = await this.apiClient.runCapability(
+      workerId,
+      capabilityName,
+      capabilityFunction,
+      argsList,
+      true
+    );
+    if (Result.isSuccess(result)) {
+      const decoder = new TextDecoder();
+      let buffer = "";
+      const allOutput = [];
+      const onBodyLine = async (jsonLine) => {
+        try {
+          const parsedLine = JSON.parse(jsonLine);
+          switch (parsedLine._tag) {
+            case "log":
+              if (parsedLine.event.stream === "stdout") {
+                allOutput.push(parsedLine.event.data);
+              }
+              parsedLine.event.data.trim().split("\n").forEach((dataLine) => {
+                this.writer.writeErr(
+                  `[worker:${parsedLine.event.stream}] ${dataLine.trim()}`
+                );
+              });
+              break;
+            case "result":
+              this.writer.writeOut(JSON.stringify(parsedLine.result, null, 2));
+              break;
+            case "error":
+              this.writer.writeErr(`Error: ${parsedLine.error}`);
+              break;
+          }
+        } catch (error) {
+          this.writer.writeErr(`Error parsing log line: ${jsonLine}: ${error}`);
+        }
+      };
+      for await (const log of result.value) {
+        const output = decoder.decode(log);
+        buffer += output;
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          await onBodyLine(line);
+        }
+      }
+      if (buffer) {
+        await onBodyLine(buffer);
+      }
+      return;
+    } else {
+      this.writer.writeErr(`
+\u2717 Failed to execute capability`);
+      if (result.error.validationError) {
+        this.writer.writeErr(`	\u2717 HTTP Error: ${result.error.status}`);
+        this.writer.writeErr(
+          `	\u2717 ${result.error.validationError.debugMessage}`
+        );
+        this.writer.writeErr(`
+${usageHint}`);
+        throw new Error(result.error.validationError.debugMessage);
+      } else {
+        this.writer.writeErr(`	\u2717 HTTP Error: ${result.error.status}`);
+        this.writer.writeErr(`	\u2717 ${result.error.message}`);
+        throw new Error(result.error.message);
+      }
+    }
+  } else {
+    const result = await this.apiClient.runCapability(
+      workerId,
+      capabilityName,
+      capabilityFunction,
+      argsList,
+      false
+    );
+    if (Result.isSuccess(result)) {
+      const data = Result.unwrap(result);
+      this.writer.writeOut(JSON.stringify(data.result, null, 2));
+    } else {
+      this.writer.writeErr(`
+\u2717 Failed to execute capability`);
+      this.writer.writeErr(`	\u2717 ${result.error.message}`);
+      throw new Error(result.error.message);
+    }
+  }
+});
+function usageError() {
+  return new Error(`Invalid arguments provided. ${usageHint}`);
+}
+export {
+  exec
+};

package/dist/cli/commands/exec.js

@@ -0,0 +1,30 @@
+import { buildCommand } from "@stricli/core";
+import { globalFlags } from "../flags.js";
+var exec_default = buildCommand({
+  docs: {
+    brief: "Execute a worker capability with optional function and arguments"
+  },
+  parameters: {
+    positional: {
+      kind: "array",
+      parameter: {
+        brief: "Capability name, optional function name, and arguments (key value pairs)",
+        parse: String,
+        placeholder: "capabilityName [functionName] [key value]..."
+      },
+      minimum: 1
+    },
+    flags: {
+      ...globalFlags,
+      stream: {
+        kind: "boolean",
+        brief: "Stream the output of the capability",
+        default: true
+      }
+    }
+  },
+  loader: () => import("./exec.impl.js").then((m) => m.exec)
+});
+export {
+  exec_default as default
+};

package/dist/cli/commands/runs.d.ts

@@ -0,0 +1,2 @@
+export declare const runsCommands: import("@stricli/core").RouteMap<import("../context.js").LocalContext>;
+//# sourceMappingURL=runs.d.ts.map

package/dist/cli/commands/runs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runs.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/runs.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,YAAY,wEA6CvB,CAAC"}

package/dist/cli/commands/runs.impl.d.ts

@@ -0,0 +1,4 @@
+import type { FormatFlags, GlobalFlags } from "../flags.js";
+export declare const listRuns: (this: import("../context.js").LocalContext, flags: GlobalFlags & FormatFlags) => Promise<void>;
+export declare const getRunLogs: (this: import("../context.js").LocalContext, flags: GlobalFlags, runId: string) => Promise<void>;
+//# sourceMappingURL=runs.impl.d.ts.map

package/dist/cli/commands/runs.impl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runs.impl.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/runs.impl.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAG5D,eAAO,MAAM,QAAQ,iGA2CnB,CAAC;AAEH,eAAO,MAAM,UAAU,kGAqCrB,CAAC"}

package/dist/cli/commands/runs.impl.js

@@ -0,0 +1,71 @@
+import { Result } from "../api/result.js";
+import { buildAuthedHandler } from "../handler.js";
+const listRuns = buildAuthedHandler(async function(flags) {
+  const { workerId } = this.config;
+  if (!workerId) {
+    throw new Error(
+      "No worker configured. Run 'workers deploy' first to create a worker."
+    );
+  }
+  this.process.stderr.write("Fetching runs...");
+  const result = await this.apiClient.listRunsForWorker(workerId);
+  if (Result.isSuccess(result)) {
+    this.process.stderr.write("OK\n\n");
+    const data = Result.unwrap(result);
+    if (data.runs.length === 0) {
+      this.writer.writeErr("No runs found for this worker.");
+    } else {
+      this.writer.writeTableOut({
+        headers: ["Run ID", "Name", "Started At", "Ended At", "Exit Code"],
+        rows: data.runs.map((run) => [
+          run.runId,
+          run.name,
+          run.startedAt,
+          run.endedAt,
+          run.exitCode
+        ]),
+        plain: flags.plain
+      });
+    }
+  } else {
+    this.process.stderr.write("ERROR\n\n");
+    if (result.error.validationError) {
+      this.writer.writeErr(`\u2717 ${result.error.validationError.debugMessage}`);
+      throw new Error(result.error.validationError.debugMessage);
+    } else {
+      this.writer.writeErr(`\u2717 ${result.error.message}`);
+      throw new Error(result.error.message);
+    }
+  }
+});
+const getRunLogs = buildAuthedHandler(async function(_flags, runId) {
+  const { workerId } = this.config;
+  if (!workerId) {
+    throw new Error(
+      "No worker configured. Run 'workers deploy' first to create a worker."
+    );
+  }
+  if (!runId) {
+    throw new Error("Run ID is required");
+  }
+  this.process.stderr.write(`Fetching logs for run ${runId}...`);
+  const result = await this.apiClient.getRunLogs(workerId, runId);
+  if (Result.isSuccess(result)) {
+    this.process.stderr.write("OK\n\n");
+    const data = Result.unwrap(result);
+    this.writer.writeOut(data.logs);
+  } else {
+    this.process.stderr.write("ERROR\n\n");
+    if (result.error.validationError) {
+      this.writer.writeErr(`\u2717 ${result.error.validationError.debugMessage}`);
+      throw new Error(result.error.validationError.debugMessage);
+    } else {
+      this.writer.writeErr(`\u2717 ${result.error.message}`);
+      throw new Error(result.error.message);
+    }
+  }
+});
+export {
+  getRunLogs,
+  listRuns
+};