@project-ajax/sdk 0.0.28

package/dist/cli/commands/runs.js

@@ -0,0 +1,45 @@
+import { buildCommand, buildRouteMap } from "@stricli/core";
+import { formatFlags, globalFlags } from "../flags.js";
+const runsCommands = buildRouteMap({
+  docs: {
+    brief: "Commands for managing worker runs"
+  },
+  routes: {
+    list: buildCommand({
+      docs: {
+        brief: "List all runs for a worker"
+      },
+      parameters: {
+        flags: {
+          ...globalFlags,
+          ...formatFlags
+        }
+      },
+      loader: () => import("./runs.impl.js").then((m) => m.listRuns)
+    }),
+    logs: buildCommand({
+      docs: {
+        brief: "Get logs for a specific run"
+      },
+      parameters: {
+        positional: {
+          kind: "tuple",
+          parameters: [
+            {
+              brief: "The run ID to get logs for",
+              parse: String,
+              placeholder: "runId"
+            }
+          ]
+        },
+        flags: {
+          ...globalFlags
+        }
+      },
+      loader: () => import("./runs.impl.js").then((m) => m.getRunLogs)
+    })
+  }
+});
+export {
+  runsCommands
+};

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

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

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

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

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

@@ -0,0 +1,5 @@
+import type { FormatFlags, GlobalFlags } from "../flags.js";
+export declare const setSecrets: (this: import("../context.js").LocalContext, flags: GlobalFlags, ...args: string[]) => Promise<void>;
+export declare const listSecrets: (this: import("../context.js").LocalContext, flags: GlobalFlags & FormatFlags) => Promise<void>;
+export declare const removeSecret: (this: import("../context.js").LocalContext, flags: GlobalFlags, key: string) => Promise<void>;
+//# sourceMappingURL=secrets.impl.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"secrets.impl.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/secrets.impl.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAK5D,eAAO,MAAM,UAAU,sGA0BrB,CAAC;AAEH,eAAO,MAAM,WAAW,iGAkCtB,CAAC;AAEH,eAAO,MAAM,YAAY,gGAwBvB,CAAC"}

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

@@ -0,0 +1,93 @@
+import { Result } from "../api/result.js";
+import { buildAuthedHandler } from "../handler.js";
+import { chunkEvery } from "../utils/array.js";
+import { pluralize } from "../utils/string.js";
+const setSecrets = buildAuthedHandler(async function(_flags, ...args) {
+  const secrets = parseSecretArgs(args);
+  const { workerId } = this.config;
+  if (!workerId) {
+    throw new Error(
+      "No worker configured. Run 'workers deploy' first to create a worker."
+    );
+  }
+  this.writer.writeErr(`Setting ${pluralize(secrets.length, "secret")}...`);
+  const result = await this.apiClient.upsertSecrets(workerId, secrets);
+  if (Result.isSuccess(result)) {
+    for (const secret of Result.unwrap(result).secrets) {
+      this.writer.writeErr(`Set secret "${secret.key}"`);
+    }
+  } else {
+    this.writer.writeErr(`\u2717 Failed to set secrets`);
+    this.writer.writeErr(`\u2717 ${result.error.message}`);
+    throw new Error(result.error.message);
+  }
+});
+const listSecrets = 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 secrets...`);
+  const result = await this.apiClient.listSecrets(workerId);
+  if (Result.isSuccess(result)) {
+    this.process.stderr.write("OK\n\n");
+    const data = Result.unwrap(result);
+    if (data.secrets.length === 0) {
+      this.writer.writeErr("No secrets for this worker.");
+    } else {
+      this.writer.writeTableOut({
+        headers: ["Key", "Created At"],
+        rows: data.secrets.map((secret) => [secret.key, secret.createdAt]),
+        plain: flags.plain
+      });
+    }
+  } else {
+    this.process.stderr.write("ERROR\n\n");
+    this.writer.writeErr(`\u2717 Failed to list secrets`);
+    this.writer.writeErr(`\u2717 ${result.error.message}`);
+    throw new Error(result.error.message);
+  }
+});
+const removeSecret = buildAuthedHandler(async function(_flags, key) {
+  const { workerId } = this.config;
+  if (!workerId) {
+    throw new Error(
+      "No worker configured. Run 'workers deploy' first to create a worker."
+    );
+  }
+  this.process.stderr.write(`Removing secret "${key}"...`);
+  const result = await this.apiClient.deleteSecret(workerId, key);
+  if (Result.isSuccess(result)) {
+    this.process.stderr.write("OK\n\n");
+  } else {
+    this.process.stderr.write("ERROR\n\n");
+    this.writer.writeErr(`\u2717 Failed to remove secret "${key}"`);
+    this.writer.writeErr(`\u2717 ${result.error.message}`);
+    throw new Error(result.error.message);
+  }
+});
+function usageError() {
+  return new Error(
+    "Invalid secrets provided. Usage: workers secrets set <key> <value> [<key2> <value2>...] or <key>=<value> [<key2>=<value2>...]"
+  );
+}
+function parseSecretArgs(args) {
+  if (args.length === 0) {
+    throw usageError();
+  }
+  const tokens = args.flatMap((arg) => arg.split(/[=:]/));
+  const secrets = chunkEvery(tokens, 2).map(([key, value]) => {
+    if (!key || !value) {
+      throw usageError();
+    }
+    return { key, value };
+  });
+  return secrets;
+}
+export {
+  listSecrets,
+  removeSecret,
+  setSecrets
+};

package/dist/cli/commands/secrets.js

@@ -0,0 +1,64 @@
+import { buildCommand, buildRouteMap } from "@stricli/core";
+import { formatFlags, globalFlags } from "../flags.js";
+const secretsCommands = buildRouteMap({
+  docs: {
+    brief: "Commands for managing worker secrets"
+  },
+  routes: {
+    set: buildCommand({
+      docs: {
+        brief: "Set one or more secrets for a worker. Supports 'key value' or 'key=value' format."
+      },
+      parameters: {
+        positional: {
+          kind: "array",
+          parameter: {
+            brief: "Secret key-value pairs (key value or key=value)",
+            parse: String,
+            placeholder: "secrets..."
+          }
+        },
+        flags: {
+          ...globalFlags
+        }
+      },
+      loader: () => import("./secrets.impl.js").then((m) => m.setSecrets)
+    }),
+    list: buildCommand({
+      docs: {
+        brief: "List all secrets for a worker (keys only)"
+      },
+      parameters: {
+        flags: {
+          ...globalFlags,
+          ...formatFlags
+        }
+      },
+      loader: () => import("./secrets.impl.js").then((m) => m.listSecrets)
+    }),
+    rm: buildCommand({
+      docs: {
+        brief: "Remove a secret from a worker"
+      },
+      parameters: {
+        positional: {
+          kind: "tuple",
+          parameters: [
+            {
+              brief: "The secret key name to remove",
+              parse: String,
+              placeholder: "key"
+            }
+          ]
+        },
+        flags: {
+          ...globalFlags
+        }
+      },
+      loader: () => import("./secrets.impl.js").then((m) => m.removeSecret)
+    })
+  }
+});
+export {
+  secretsCommands
+};

package/dist/cli/config.d.ts

@@ -0,0 +1,38 @@
+export declare const Environments: readonly ["local", "staging", "dev", "prod"];
+export type Environment = (typeof Environments)[number];
+interface ConfigFile {
+    environment?: Environment;
+    baseUrl?: string;
+    token: string | null;
+    workerId: string | null;
+}
+export declare function parseEnvironment(name: string): Environment;
+export declare class TokenNotSetError extends Error {
+    constructor(message?: string);
+}
+export declare function parseEnvironmentName(name: string): Environment;
+export declare class Config {
+    #private;
+    constructor(configFilePath: string, configFile: ConfigFile);
+    setEnvironment(environment: Environment): Promise<void>;
+    setBaseUrl(baseUrl: string): Promise<void>;
+    get baseUrl(): string | undefined;
+    get token(): string | null;
+    get tokenInfo(): {
+        token: string;
+        spaceId: string;
+        cellId: string;
+    };
+    get environment(): "local" | "staging" | "dev" | "prod" | undefined;
+    get workerId(): string | null;
+    setToken(token: string | null): Promise<void>;
+    setWorkerId(workerId: string | null): Promise<void>;
+    static load(configFilePath: string): Promise<Config>;
+}
+export declare function extractPayloadFromToken(token: string): {
+    spaceId: string;
+    userId: string;
+    cellId: string;
+};
+export {};
+//# sourceMappingURL=config.d.ts.map

package/dist/cli/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/cli/config.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,YAAY,8CAA+C,CAAC;AACzE,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,CAAC,CAAC;AAExD,UAAU,UAAU;IACnB,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;CACxB;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,CAM1D;AAED,qBAAa,gBAAiB,SAAQ,KAAK;gBAEzC,OAAO,GAAE,MAA6D;CAKvE;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,CAM9D;AAED,qBAAa,MAAM;;gBAIN,cAAc,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU;IAKpD,cAAc,CAAC,WAAW,EAAE,WAAW;IAKvC,UAAU,CAAC,OAAO,EAAE,MAAM;IAKhC,IAAI,OAAO,uBAEV;IAED,IAAI,KAAK,kBAER;IAED,IAAI,SAAS,IAAI;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAQlE;IAED,IAAI,WAAW,qDAEd;IAED,IAAI,QAAQ,kBAEX;IAEK,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAK7B,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;WAa5B,IAAI,CAAC,cAAc,EAAE,MAAM;CAyBxC;AAQD,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,GAAG;IACvD,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CACf,CAoCA"}

package/dist/cli/config.js

@@ -0,0 +1,133 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+const Environments = ["local", "staging", "dev", "prod"];
+function parseEnvironment(name) {
+  if (["local", "staging", "dev", "prod"].includes(name)) {
+    return name;
+  }
+  throw new Error(`Invalid environment name: ${name}`);
+}
+class TokenNotSetError extends Error {
+  constructor(message = "Not authenticated. Run 'workers auth login' first.") {
+    super(message);
+    this.name = "TokenNotSetError";
+  }
+}
+function parseEnvironmentName(name) {
+  if (["local", "staging", "dev", "prod"].includes(name)) {
+    return name;
+  }
+  throw new Error(`Invalid environment name: ${name}`);
+}
+class Config {
+  #configFile;
+  #configFilePath;
+  constructor(configFilePath, configFile) {
+    this.#configFilePath = configFilePath;
+    this.#configFile = configFile;
+  }
+  async setEnvironment(environment) {
+    this.#configFile.environment = environment;
+    await this.#writeConfigFile();
+  }
+  async setBaseUrl(baseUrl) {
+    this.#configFile.baseUrl = baseUrl;
+    await this.#writeConfigFile();
+  }
+  get baseUrl() {
+    return this.#configFile.baseUrl;
+  }
+  get token() {
+    return this.#configFile.token;
+  }
+  get tokenInfo() {
+    const token = this.#configFile.token;
+    if (!token) {
+      throw new TokenNotSetError();
+    }
+    const { spaceId, cellId } = extractPayloadFromToken(token);
+    return { token, spaceId, cellId };
+  }
+  get environment() {
+    return this.#configFile.environment;
+  }
+  get workerId() {
+    return this.#configFile.workerId;
+  }
+  async setToken(token) {
+    this.#configFile.token = token;
+    await this.#writeConfigFile();
+  }
+  async setWorkerId(workerId) {
+    this.#configFile.workerId = workerId;
+    await this.#writeConfigFile();
+  }
+  async #writeConfigFile() {
+    await fs.promises.writeFile(
+      this.#configFilePath,
+      JSON.stringify(this.#configFile, null, 2),
+      "utf-8"
+    );
+  }
+  static async load(configFilePath) {
+    const absConfigFilePath = path.resolve(process.cwd(), configFilePath);
+    const configFile = await Config.#readConfigFile(absConfigFilePath);
+    return new Config(absConfigFilePath, configFile);
+  }
+  static async #readConfigFile(configFilePath) {
+    let configFile;
+    try {
+      const configContents = await fs.promises.readFile(
+        configFilePath,
+        "utf-8"
+      );
+      configFile = JSON.parse(configContents);
+    } catch (error) {
+      if (isENOENT(error)) {
+        configFile = { token: null, workerId: null };
+      } else {
+        throw error;
+      }
+    }
+    return configFile;
+  }
+}
+function isENOENT(error) {
+  return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+function extractPayloadFromToken(token) {
+  try {
+    const parts = token.split(".");
+    if (parts.length !== 4 || !parts[2]) {
+      throw new Error("Invalid token format.");
+    }
+    const payloadBase64 = parts[2];
+    const payloadJson = Buffer.from(payloadBase64, "base64url").toString(
+      "utf-8"
+    );
+    const payload = JSON.parse(payloadJson);
+    if (!payload.spaceId || !payload.userId || !payload.cellId) {
+      throw new Error(
+        "Token payload missing required fields (spaceId, userId, cellId)."
+      );
+    }
+    return {
+      spaceId: payload.spaceId,
+      userId: payload.userId,
+      cellId: payload.cellId
+    };
+  } catch (error) {
+    if (error instanceof Error && error.message.startsWith("Token")) {
+      throw error;
+    }
+    throw new Error("Failed to parse token payload.");
+  }
+}
+export {
+  Config,
+  Environments,
+  TokenNotSetError,
+  extractPayloadFromToken,
+  parseEnvironment,
+  parseEnvironmentName
+};

package/dist/cli/context.d.ts

@@ -0,0 +1,15 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import type { StricliAutoCompleteContext } from "@stricli/auto-complete";
+import type { CommandContext } from "@stricli/core";
+import { Writer } from "./writer.js";
+export interface LocalContext extends CommandContext, StricliAutoCompleteContext {
+    readonly fs: typeof fs;
+    readonly os: typeof os;
+    readonly path: typeof path;
+    readonly process: NodeJS.Process;
+    readonly writer: Writer;
+}
+export declare function buildContext(process: NodeJS.Process): LocalContext;
+//# sourceMappingURL=context.d.ts.map

package/dist/cli/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/cli/context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,SAAS,CAAC;AAC9B,OAAO,KAAK,EAAE,MAAM,SAAS,CAAC;AAC9B,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAClC,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,wBAAwB,CAAC;AACzE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AACpD,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC,MAAM,WAAW,YAChB,SAAQ,cAAc,EACrB,0BAA0B;IAC3B,QAAQ,CAAC,EAAE,EAAE,OAAO,EAAE,CAAC;IACvB,QAAQ,CAAC,EAAE,EAAE,OAAO,EAAE,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,OAAO,IAAI,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,OAAO,CAAC;IACjC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACxB;AAED,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,CAAC,OAAO,GAAG,YAAY,CAQlE"}

package/dist/cli/context.js

@@ -0,0 +1,16 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { Writer } from "./writer.js";
+function buildContext(process) {
+  return {
+    fs,
+    os,
+    path,
+    process,
+    writer: new Writer({ debugEnabled: false })
+  };
+}
+export {
+  buildContext
+};

package/dist/cli/deploy.d.ts

@@ -0,0 +1,25 @@
+import type { ApiError, Environment } from "./api/client.js";
+import { Result } from "./api/result.js";
+import type { AuthedContext } from "./handler.js";
+export interface DeployOptions {
+    /**
+     * Path to the worker directory to deploy
+     */
+    workerPath: string;
+    /**
+     * API token for authentication
+     */
+    token: string;
+    /**
+     * Environment to deploy to
+     */
+    environment: Environment;
+    workerId?: string | null;
+}
+/**
+ * Deploy a worker to the specified environment
+ */
+export declare function deployWorker(context: AuthedContext, options: DeployOptions): Promise<Result<{
+    workerId: string;
+}, ApiError>>;
+//# sourceMappingURL=deploy.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"deploy.d.ts","sourceRoot":"","sources":["../../src/cli/deploy.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAC7D,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAEzC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAElD,MAAM,WAAW,aAAa;IAC7B;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;OAEG;IACH,WAAW,EAAE,WAAW,CAAC;IAEzB,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACzB;AAED;;GAEG;AACH,wBAAsB,YAAY,CACjC,OAAO,EAAE,aAAa,EACtB,OAAO,EAAE,aAAa,GACpB,OAAO,CAAC,MAAM,CAAC;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,EAAE,QAAQ,CAAC,CAAC,CAiEjD"}

package/dist/cli/deploy.js

@@ -0,0 +1,101 @@
+import * as childProcess from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as esbuild from "esbuild";
+import { Result } from "./api/result.js";
+async function deployWorker(context, options) {
+  const { workerPath, workerId: workerIdForUpdate } = options;
+  const absPath = path.resolve(process.cwd(), workerPath);
+  context.writer.debug(`Deploying worker from: ${absPath}`);
+  const client = context.apiClient;
+  let uploadUrl;
+  let uploadFields;
+  let workerId;
+  context.writer.writeErr(
+    workerIdForUpdate ? `Updating worker...` : `Creating worker...`
+  );
+  if (workerIdForUpdate) {
+    workerId = workerIdForUpdate;
+    const updateResult = await client.updateWorkerBundle(workerIdForUpdate);
+    if (Result.isSuccess(updateResult)) {
+      const res = Result.unwrap(updateResult);
+      uploadUrl = res.url;
+      uploadFields = res.fields;
+    } else {
+      context.writer.writeErr(
+        "Failed to generate pre-signed upload URL for worker bundle:"
+      );
+      throw new Error(updateResult.error.message);
+    }
+  } else {
+    const createResult = await client.createWorker("tmp-give-me-a-good-name");
+    if (Result.isSuccess(createResult)) {
+      const res = Result.unwrap(createResult);
+      uploadUrl = res.url;
+      uploadFields = res.fields;
+      workerId = res.worker.workerId;
+    } else {
+      console.error("Failed to create worker:");
+      throw new Error(createResult.error.message);
+    }
+  }
+  context.writer.debug(`Generated upload URL: ${uploadUrl}`);
+  context.writer.writeErr("Building worker bundle...");
+  const archivePath = await buildWorkerBundle(context, absPath);
+  context.writer.debug(`Created bundle at: ${archivePath}`);
+  context.writer.writeErr("Uploading bundle...");
+  await uploadBundle(uploadUrl, uploadFields, archivePath);
+  context.writer.debug("Upload complete");
+  context.writer.writeErr("Fetching and saving worker capabilities...");
+  const capabilitiesResult = await client.fetchAndSaveCapabilities(workerId);
+  if (Result.isSuccess(capabilitiesResult)) {
+    return Result.success({ workerId });
+  } else {
+    return capabilitiesResult;
+  }
+}
+async function buildWorkerBundle(context, workerPath) {
+  const entrypoint = "src/index.ts";
+  if (!fs.existsSync(path.join(workerPath, entrypoint))) {
+    throw new Error(`Entrypoint not found: ${entrypoint}`);
+  }
+  const outdir = fs.mkdtempSync("/tmp/workers-build-");
+  esbuild.buildSync({
+    entryPoints: [entrypoint],
+    absWorkingDir: workerPath,
+    bundle: true,
+    outdir,
+    platform: "node"
+  });
+  context.writer.debug(`Built bundle to: ${outdir}`);
+  const archiveDir = fs.mkdtempSync("/tmp/workers-archive-");
+  const archivePath = path.join(archiveDir, "archive.tar.gz");
+  childProcess.execSync(`tar -czf ${archivePath} -C ${outdir} .`);
+  return archivePath;
+}
+async function uploadBundle(url, fields, archivePath) {
+  const formData = new FormData();
+  for (const [key, value] of Object.entries(fields)) {
+    formData.append(key, value);
+  }
+  const fileBuffer = fs.readFileSync(archivePath);
+  formData.append(
+    "file",
+    new Blob([new Uint8Array(fileBuffer)]),
+    "archive.tar.gz"
+  );
+  const response = await fetch(url, {
+    method: "POST",
+    body: formData
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(
+      `Failed to upload bundle: ${response.status} ${response.statusText}
+${errorText}`
+    );
+  }
+}
+export {
+  deployWorker
+};

package/dist/cli/flags.d.ts

@@ -0,0 +1,16 @@
+import type { TypedFlagParameter } from "@stricli/core";
+import type { LocalContext } from "./context.js";
+export interface GlobalFlags {
+    config?: string;
+    debug: boolean;
+}
+export declare const globalFlags: {
+    [K in keyof Required<GlobalFlags>]: TypedFlagParameter<GlobalFlags[K], LocalContext>;
+};
+export interface FormatFlags {
+    plain: boolean;
+}
+export declare const formatFlags: {
+    [K in keyof Required<FormatFlags>]: TypedFlagParameter<FormatFlags[K], LocalContext>;
+};
+//# sourceMappingURL=flags.d.ts.map

package/dist/cli/flags.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flags.d.ts","sourceRoot":"","sources":["../../src/cli/flags.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACxD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAEjD,MAAM,WAAW,WAAW;IAC3B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,OAAO,CAAC;CACf;AAED,eAAO,MAAM,WAAW,EAAE;KACxB,CAAC,IAAI,MAAM,QAAQ,CAAC,WAAW,CAAC,GAAG,kBAAkB,CACrD,WAAW,CAAC,CAAC,CAAC,EACd,YAAY,CACZ;CAaD,CAAC;AAEF,MAAM,WAAW,WAAW;IAC3B,KAAK,EAAE,OAAO,CAAC;CACf;AAED,eAAO,MAAM,WAAW,EAAE;KACxB,CAAC,IAAI,MAAM,QAAQ,CAAC,WAAW,CAAC,GAAG,kBAAkB,CACrD,WAAW,CAAC,CAAC,CAAC,EACd,YAAY,CACZ;CAOD,CAAC"}

package/dist/cli/flags.js

@@ -0,0 +1,24 @@
+const globalFlags = {
+  config: {
+    kind: "parsed",
+    parse: String,
+    brief: "The path to the config file to use",
+    optional: true
+  },
+  debug: {
+    kind: "boolean",
+    brief: "Enable debug logging",
+    default: false
+  }
+};
+const formatFlags = {
+  plain: {
+    kind: "boolean",
+    brief: "Output the results in plain text format",
+    default: false
+  }
+};
+export {
+  formatFlags,
+  globalFlags
+};

package/dist/cli/handler.d.ts

@@ -0,0 +1,14 @@
+import type { BaseArgs } from "@stricli/core";
+import { ApiClient } from "./api/client.js";
+import { Config } from "./config.js";
+import type { LocalContext } from "./context.js";
+import type { GlobalFlags } from "./flags.js";
+export interface HandlerContext extends LocalContext {
+    config: Config;
+}
+export interface AuthedContext extends HandlerContext {
+    apiClient: ApiClient;
+}
+export declare function buildHandler<const FLAGS, const ARGS extends BaseArgs = []>(handler: (this: HandlerContext, flags: FLAGS, ...args: ARGS) => Promise<void> | void): (this: LocalContext, flags: GlobalFlags & FLAGS, ...args: ARGS) => Promise<void>;
+export declare function buildAuthedHandler<const FLAGS, const ARGS extends BaseArgs = []>(handler: (this: AuthedContext, flags: FLAGS, ...args: ARGS) => Promise<void> | void): (this: LocalContext, flags: GlobalFlags & FLAGS, ...args: ARGS) => Promise<void>;
+//# sourceMappingURL=handler.d.ts.map

package/dist/cli/handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handler.d.ts","sourceRoot":"","sources":["../../src/cli/handler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AACjD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C,MAAM,WAAW,cAAe,SAAQ,YAAY;IACnD,MAAM,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,aAAc,SAAQ,cAAc;IACpD,SAAS,EAAE,SAAS,CAAC;CACrB;AAED,wBAAgB,YAAY,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,IAAI,SAAS,QAAQ,GAAG,EAAE,EACzE,OAAO,EAAE,CACR,IAAI,EAAE,cAAc,EACpB,KAAK,EAAE,KAAK,EACZ,GAAG,IAAI,EAAE,IAAI,KACT,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,IAGxB,MAAM,YAAY,EAClB,OAAO,WAAW,GAAG,KAAK,EAC1B,GAAG,MAAM,IAAI,mBAQd;AAED,wBAAgB,kBAAkB,CACjC,KAAK,CAAC,KAAK,EACX,KAAK,CAAC,IAAI,SAAS,QAAQ,GAAG,EAAE,EAEhC,OAAO,EAAE,CACR,IAAI,EAAE,aAAa,EACnB,KAAK,EAAE,KAAK,EACZ,GAAG,IAAI,EAAE,IAAI,KACT,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,UApBlB,YAAY,8DAuCnB"}

package/dist/cli/handler.js

@@ -0,0 +1,30 @@
+import { ApiClient } from "./api/client.js";
+import { Config } from "./config.js";
+function buildHandler(handler) {
+  return async function(flags, ...args) {
+    const config = await Config.load(flags.config ?? "./workers.json");
+    this.writer.debugEnabled = flags.debug;
+    await handler.call({ ...this, config }, flags, ...args);
+  };
+}
+function buildAuthedHandler(handler) {
+  return buildHandler(function(flags, ...args) {
+    const environment = this.config.environment;
+    if (!environment) {
+      throw new Error("Unexpected error: Environment not set");
+    }
+    const { token, cellId } = this.config.tokenInfo;
+    const client = new ApiClient({
+      token,
+      environment,
+      baseUrl: this.config.baseUrl,
+      cellId,
+      writer: this.writer
+    });
+    return handler.call({ ...this, apiClient: client }, flags, ...args);
+  });
+}
+export {
+  buildAuthedHandler,
+  buildHandler
+};

package/dist/cli/routes.d.ts

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

package/dist/cli/routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../../src/cli/routes.ts"],"names":[],"mappings":"AA0BA,eAAO,MAAM,GAAG,0EAgBd,CAAC"}