@asteroidai/cli 1.9.12 → 1.9.28

package/src/request.ts

@@ -1,252 +0,0 @@
-import { readFileSync } from "node:fs";
-import { basename } from "node:path";
-
-import { type Parsed, UsageError } from "./args";
-import type { CliCommand, Option } from "./types";
-
-export interface BuiltRequest {
-  method: CliCommand["method"];
-  path: string;
-  query: URLSearchParams;
-  json?: unknown;
-  form?: FormData;
-}
-
-function camel(segment: string): string {
-  return segment.replace(/-([a-z0-9])/g, (_, c: string) => c.toUpperCase());
-}
-
-function scalar(option: Option, raw: string): unknown {
-  const type = option.type.replace("[]", "");
-  if (option.enum && !option.enum.includes(raw)) {
-    throw new UsageError(
-      `--${option.flag} must be one of ${option.enum.join(", ")}`,
-    );
-  }
-  if (type === "integer" || type === "number") {
-    const value = Number(raw);
-    if (
-      raw.trim() === "" ||
-      Number.isNaN(value) ||
-      (type === "integer" && !Number.isInteger(value))
-    ) {
-      throw new UsageError(
-        `--${option.flag} must be ${type === "integer" ? "an integer" : "a number"}`,
-      );
-    }
-    return value;
-  }
-  if (type === "boolean") {
-    if (raw !== "true" && raw !== "false") {
-      throw new UsageError(`--${option.flag} must be true or false`);
-    }
-    return raw === "true";
-  }
-  if (type === "json") return parseJson(raw, `--${option.flag}`);
-  return raw;
-}
-
-function value(option: Option, raws: string[]): unknown {
-  if (option.type.endsWith("[]")) return raws.map((raw) => scalar(option, raw));
-  return scalar(option, raws.at(-1)!);
-}
-
-export interface InputReader {
-  text(path: string | 0): Promise<string>;
-  bytes(path: string): Promise<Uint8Array<ArrayBuffer>>;
-}
-
-export const nodeReader: InputReader = {
-  text: async (path) => readFileSync(path, "utf8"),
-  bytes: async (path) => new Uint8Array(readFileSync(path)),
-};
-
-async function readInput(raw: string, io: InputReader): Promise<string> {
-  if (raw === "-") return io.text(0);
-  if (raw.startsWith("@")) return io.text(raw.slice(1));
-  return raw;
-}
-
-async function resolveInputs(
-  command: CliCommand,
-  parsed: Parsed,
-  io: InputReader,
-): Promise<Parsed> {
-  const jsonFlags = [...command.query, ...(command.body?.fields ?? [])]
-    .filter((option) => option.type === "json")
-    .map((option) => option.flag);
-  const flags = new Map(parsed.flags);
-  for (const flag of jsonFlags) {
-    const raws = flags.get(flag);
-    if (raws)
-      flags.set(flag, await Promise.all(raws.map((raw) => readInput(raw, io))));
-  }
-  const body =
-    parsed.body === undefined ? undefined : await readInput(parsed.body, io);
-  return { ...parsed, flags, body };
-}
-
-function parseJson(raw: string, label: string): unknown {
-  try {
-    return JSON.parse(raw);
-  } catch {
-    throw new UsageError(`${label} is not valid JSON`);
-  }
-}
-
-function loose(raw: string): unknown {
-  if (/^(true|false|null)$/.test(raw) || /^[[{]/.test(raw.trim())) {
-    try {
-      return JSON.parse(raw);
-    } catch {
-      return raw;
-    }
-  }
-  return raw;
-}
-
-function setPath(
-  target: Record<string, unknown>,
-  path: string[],
-  value: unknown,
-) {
-  let node = target;
-  for (const key of path.slice(0, -1)) {
-    const next = node[key];
-    if (typeof next !== "object" || next === null || Array.isArray(next))
-      node[key] = {};
-    node = node[key] as Record<string, unknown>;
-  }
-  node[path.at(-1)!] = value;
-}
-
-export interface RequestContext {
-  io?: InputReader;
-  organizationId?: string;
-}
-
-export async function buildRequest(
-  command: CliCommand,
-  input: Parsed,
-  context: RequestContext = {},
-): Promise<BuiltRequest> {
-  const io = context.io ?? nodeReader;
-  const parsed = await resolveInputs(command, input, io);
-  if (parsed.positionals.length !== command.args.length) {
-    const expected =
-      command.args.map((a) => `<${a.flag}>`).join(" ") || "no arguments";
-    throw new UsageError(
-      `expected ${expected}, got ${parsed.positionals.length} argument(s)`,
-    );
-  }
-  let path = command.path;
-  command.args.forEach((arg, i) => {
-    path = path.replace(
-      `{${arg.name}}`,
-      encodeURIComponent(parsed.positionals[i]),
-    );
-  });
-
-  const flags = new Map(parsed.flags);
-  const query = new URLSearchParams();
-  for (const option of command.query) {
-    const raws = flags.get(option.flag);
-    flags.delete(option.flag);
-    if (!raws) {
-      if (option.required) throw new UsageError(`--${option.flag} is required`);
-      continue;
-    }
-    const parsedValue = value(option, raws);
-    const values = Array.isArray(parsedValue) ? parsedValue : [parsedValue];
-    if (option.explode === false)
-      query.append(option.name, values.map(String).join(","));
-    else for (const v of values) query.append(option.name, String(v));
-  }
-
-  const built: BuiltRequest = { method: command.method, path, query };
-  const body = command.body;
-  if (!body) {
-    if (parsed.body) throw new UsageError(`${command.command} takes no body`);
-    rejectUnknown(flags);
-    return built;
-  }
-
-  if (body.contentType === "multipart/form-data") {
-    if (parsed.body) {
-      throw new UsageError(
-        `${command.command} uploads files; use the file flags, not --body`,
-      );
-    }
-    const form = new FormData();
-    for (const file of body.files) {
-      const paths = flags.get(file) ?? [];
-      if (body.required && paths.length === 0) {
-        throw new UsageError(`--${file} is required`);
-      }
-      for (const filePath of paths) {
-        form.append(
-          file,
-          new Blob([await io.bytes(filePath)]),
-          basename(filePath),
-        );
-      }
-      flags.delete(file);
-    }
-    for (const field of body.fields) {
-      const raws = flags.get(field.flag);
-      flags.delete(field.flag);
-      if (raws) for (const raw of raws) form.append(field.name, raw);
-    }
-    rejectUnknown(flags);
-    built.form = form;
-    return built;
-  }
-
-  const base = parsed.body ? parseJson(parsed.body, "--body") : {};
-  if (typeof base !== "object" || base === null || Array.isArray(base)) {
-    throw new UsageError("--body must be a JSON object");
-  }
-  const json = base as Record<string, unknown>;
-  for (const field of body.fields) {
-    const raws = flags.get(field.flag);
-    if (!raws) continue;
-    flags.delete(field.flag);
-    json[field.name] = value(field, raws);
-  }
-  for (const [flag, raws] of [...flags]) {
-    const [head, ...rest] = flag.split(".");
-    const field = body.fields.find((f) => f.flag === head);
-    if (!field || rest.length === 0) continue;
-    flags.delete(flag);
-    const current = json[field.name];
-    json[field.name] =
-      typeof current === "object" && current !== null ? current : {};
-    setPath(json, [field.name, ...rest.map(camel)], loose(raws.at(-1)!));
-  }
-  rejectUnknown(flags);
-  delete json.organizationId;
-  if (body.credentialOrganization) {
-    if (!context.organizationId) {
-      throw new UsageError(
-        "could not tell which organization this credential acts in",
-      );
-    }
-    json.organizationId = context.organizationId;
-  }
-  for (const field of body.fields) {
-    if (field.required && json[field.name] === undefined) {
-      throw new UsageError(`--${field.flag} is required`);
-    }
-  }
-  if (body.required || Object.keys(json).length > 0) built.json = json;
-  return built;
-}
-
-function rejectUnknown(flags: Map<string, string[]>) {
-  const unknown = [...flags.keys()];
-  if (unknown.length > 0) {
-    throw new UsageError(
-      `unknown flag${unknown.length > 1 ? "s" : ""}: ${unknown.map((f) => `--${f}`).join(", ")}`,
-    );
-  }
-}

package/src/run.test.ts

@@ -1,431 +0,0 @@
-import { mkdtempSync, readFileSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { beforeEach, describe, expect, it } from "vitest";
-
-import { CredentialStore } from "./auth/store";
-import { ALL_COMMANDS } from "./commands";
-import { readEnv, saveConfig } from "./config";
-import { renderReference } from "./reference";
-import { type Deps, run } from "./run";
-
-interface Call {
-  url: string;
-  init: RequestInit;
-}
-
-function jwt(claims: Record<string, unknown>): string {
-  const part = (value: unknown) =>
-    Buffer.from(JSON.stringify(value)).toString("base64url");
-  return `${part({ alg: "none" })}.${part(claims)}.sig`;
-}
-
-function harness(
-  env: Record<string, string>,
-  respond: (call: Call) => Response,
-) {
-  const configDir = mkdtempSync(join(tmpdir(), "asteroid-cli-"));
-  const calls: Call[] = [];
-  const out: string[] = [];
-  const err: string[] = [];
-  const deps: Deps = {
-    env: readEnv({ ASTEROID_CONFIG_DIR: configDir, ...env }),
-    cwd: configDir,
-    fetch: (async (url: string, init: RequestInit) => {
-      const call = { url: String(url), init };
-      calls.push(call);
-      return respond(call);
-    }) as typeof fetch,
-    stdout: (text) => out.push(text),
-    stderr: (text) => err.push(text),
-    writeBytes: () => undefined,
-  };
-  return { deps, calls, out, err, configDir };
-}
-
-const json = (body: unknown, status = 200) =>
-  new Response(JSON.stringify(body), {
-    status,
-    headers: { "content-type": "application/json" },
-  });
-
-beforeEach(() => {
-  process.env.ASTEROID_NO_KEYCHAIN = "1";
-});
-
-describe("run", () => {
-  it("sends the API key and prints a table", async () => {
-    const h = harness({ ASTEROID_API_KEY: "sk_test" }, () =>
-      json({
-        items: [{ id: "w1", name: "Fill form" }],
-        page: 1,
-        pageSize: 50,
-        total: 1,
-      }),
-    );
-    const code = await run(["workflow", "list"], h.deps);
-    expect(code).toBe(0);
-    expect(h.calls[0].url).toBe(
-      "https://odyssey.asteroid.ai/agents/v2/workflows",
-    );
-    expect(
-      (h.calls[0].init.headers as Record<string, string>)["X-Api-Key"],
-    ).toBe("sk_test");
-    expect(h.out.join("")).toContain("Fill form");
-  });
-
-  it("prints the problem detail and exits 1 on an API error", async () => {
-    const h = harness({ ASTEROID_API_KEY: "sk_test" }, () =>
-      json({ detail: "Execution not found", status: 404 }, 404),
-    );
-    const code = await run(["execution", "get", "e1"], h.deps);
-    expect(code).toBe(1);
-    expect(h.err.join("")).toContain("404: Execution not found");
-  });
-
-  it("exits 2 on a usage error without calling the API", async () => {
-    const h = harness({ ASTEROID_API_KEY: "sk_test" }, () => json({}));
-    expect(await run(["workflow", "get"], h.deps)).toBe(2);
-    expect(await run(["nope"], h.deps)).toBe(2);
-    expect(h.calls).toHaveLength(0);
-  });
-
-  it("prints raw JSON with --json and names the org on a write", async () => {
-    const h = harness({ ASTEROID_API_KEY: "sk_test" }, () =>
-      json({ id: "w1" }),
-    );
-    await run(["workflow", "rename", "w1", "--name", "New", "--json"], h.deps);
-    expect(JSON.parse(h.out.join(""))).toEqual({ id: "w1" });
-    expect(h.err.join("")).toContain("Acting in the API key's organization.");
-    expect(JSON.parse(String(h.calls[0].init.body))).toEqual({ name: "New" });
-  });
-
-  it("mints an org token from the stored sign-in and caches it", async () => {
-    const access = jwt({
-      exp: Date.now() / 1000 + 300,
-      org_id: "org_A",
-      org: { id: "uuid-a", name: "Acme" },
-    });
-    const h = harness({}, (call) => {
-      if (call.url.includes("workos")) {
-        expect(
-          Object.fromEntries(call.init.body as URLSearchParams),
-        ).toMatchObject({
-          grant_type: "refresh_token",
-          refresh_token: "r1",
-          organization_id: "org_A",
-        });
-        return json({
-          access_token: access,
-          refresh_token: "r2",
-          organization_id: "org_A",
-        });
-      }
-      return json({ items: [], page: 1, pageSize: 50, total: 0 });
-    });
-    h.deps.env.workosApiUrl = "https://workos.test";
-    const store = new CredentialStore(h.deps.env);
-    await store.writeLogin({ refreshToken: "r1" });
-    saveConfig(h.deps.env, { org: { workosId: "org_A" } });
-
-    const codes = await Promise.all([
-      run(["workflow", "list"], h.deps),
-      run(["workflow", "list"], h.deps),
-    ]);
-    expect(codes).toEqual([0, 0]);
-    expect(await run(["workflow", "list"], h.deps)).toBe(0);
-
-    const workosCalls = h.calls.filter((c) => c.url.includes("workos"));
-    expect(workosCalls).toHaveLength(1);
-    expect(
-      (h.calls.at(-1)!.init.headers as Record<string, string>).Authorization,
-    ).toBe(`Bearer ${access}`);
-    expect((await store.readLogin())?.refreshToken).toBe("r2");
-    const config = JSON.parse(
-      readFileSync(join(h.configDir, "config.json"), "utf8"),
-    );
-    expect(config.org).toEqual({
-      workosId: "org_A",
-      id: "uuid-a",
-      name: "Acme",
-    });
-  });
-
-  it("asks for an org when none is set", async () => {
-    const h = harness({}, () => json({}));
-    await new CredentialStore(h.deps.env).writeLogin({ refreshToken: "r1" });
-    expect(await run(["workflow", "list"], h.deps)).toBe(1);
-    expect(h.err.join("")).toContain("asteroid use <org>");
-    expect(h.calls).toHaveLength(0);
-  });
-
-  it("sends an SSO or MFA org back to login", async () => {
-    const h = harness({}, () =>
-      json({ error: "sso_required", error_description: "SSO required" }, 400),
-    );
-    h.deps.env.workosApiUrl = "https://workos.test";
-    await new CredentialStore(h.deps.env).writeLogin({ refreshToken: "r1" });
-    saveConfig(h.deps.env, { org: { workosId: "org_A", name: "Acme" } });
-    expect(await run(["workflow", "list"], h.deps)).toBe(1);
-    expect(h.err.join("")).toContain("requires SSO or MFA");
-  });
-
-  it("asks to sign in when there is no credential", async () => {
-    const h = harness({}, () => json({}));
-    expect(await run(["workflow", "list"], h.deps)).toBe(1);
-    expect(h.err.join("")).toContain("asteroid login");
-  });
-});
-
-describe("guards", () => {
-  it("refuses --org with an API key", async () => {
-    const h = harness({ ASTEROID_API_KEY: "sk_test" }, () => json({}));
-    expect(await run(["workflow", "list", "--org", "Acme"], h.deps)).toBe(2);
-    expect(h.calls).toHaveLength(0);
-  });
-
-  it("tells a signed-in user that the API key overrides use", async () => {
-    const h = harness({ ASTEROID_API_KEY: "sk_test" }, () => json({}));
-    await new CredentialStore(h.deps.env).writeLogin({ refreshToken: "r1" });
-    expect(await run(["use", "org_A"], h.deps)).toBe(2);
-    expect(h.err.join("")).toContain("ignores `asteroid login`");
-    expect(h.err.join("")).toContain("unset ASTEROID_API_KEY");
-  });
-
-  it("names the API key when the API rejects it", async () => {
-    const h = harness({ ASTEROID_API_KEY: "sk_bad" }, () =>
-      json({ detail: "invalid API key" }, 401),
-    );
-    expect(await run(["workflow", "list"], h.deps)).toBe(1);
-    expect(h.err.join("")).toContain(
-      "401: ASTEROID_API_KEY was rejected: invalid API key.",
-    );
-  });
-
-  it("rejects extra arguments and unknown flags on account commands", async () => {
-    const h = harness({}, () => json({}));
-    expect(await run(["use", "a", "b"], h.deps)).toBe(2);
-    expect(await run(["logout", "--typo", "x"], h.deps)).toBe(2);
-  });
-
-  it("drops the API key when a download redirects to another host", async () => {
-    const h = harness({ ASTEROID_API_KEY: "sk_test" }, (call) =>
-      call.url.startsWith("https://odyssey")
-        ? new Response(null, {
-            status: 303,
-            headers: { location: "https://storage.test/file" },
-          })
-        : new Response("bytes", { status: 200 }),
-    );
-    expect(
-      await run(["execution", "file", "download", "e1", "f1"], h.deps),
-    ).toBe(0);
-    const download = h.calls[1];
-    expect(download.url).toBe("https://storage.test/file");
-    expect(
-      (download.init.headers as Record<string, string>)["X-Api-Key"],
-    ).toBeUndefined();
-  });
-
-  it("does not blame the API key for an error after a cross-host redirect", async () => {
-    const h = harness({ ASTEROID_API_KEY: "sk_test" }, (call) =>
-      call.url.startsWith("https://odyssey")
-        ? new Response(null, {
-            status: 303,
-            headers: { location: "https://storage.test/file" },
-          })
-        : new Response("expired", { status: 403 }),
-    );
-    expect(
-      await run(["execution", "file", "download", "e1", "f1"], h.deps),
-    ).toBe(1);
-    expect(h.err.join("")).toContain("403: expired");
-    expect(h.err.join("")).not.toContain("ASTEROID_API_KEY");
-  });
-
-  it("keeps the method and body on a 307", async () => {
-    const h = harness({ ASTEROID_API_KEY: "sk_test" }, (call) =>
-      call.url.endsWith("/validate")
-        ? new Response(null, {
-            status: 307,
-            headers: { location: "/agents/v2/schema/validate2" },
-          })
-        : json({ valid: true }),
-    );
-    await run(["schema", "validate", "--schema", "{}"], h.deps);
-    expect(h.calls[1].init.method).toBe("POST");
-    expect(h.calls[1].init.body).toBe('{"schema":{}}');
-    expect(
-      (h.calls[1].init.headers as Record<string, string>)["X-Api-Key"],
-    ).toBe("sk_test");
-  });
-
-  it("renders nested object lists as a table", async () => {
-    const h = harness({ ASTEROID_API_KEY: "sk_test" }, () =>
-      json({ tools: [{ name: "go_to_url", capability: "web" }] }),
-    );
-    await run(["tool", "list"], h.deps);
-    expect(h.out.join("")).toContain("go_to_url");
-  });
-});
-
-describe("cell width", () => {
-  const long = "x".repeat(80);
-  const reply = () => json({ items: [{ id: "w-1", name: long }] });
-
-  it("keeps cells whole when stdout is not a terminal", async () => {
-    const h = harness({ ASTEROID_API_KEY: "sk_test" }, reply);
-    await run(["workflow", "list"], h.deps);
-    expect(h.out.join("")).toContain(long);
-  });
-
-  it("cuts long cells at a terminal", async () => {
-    const h = harness({ ASTEROID_API_KEY: "sk_test" }, reply);
-    h.deps.stdoutIsTTY = true;
-    await run(["workflow", "list"], h.deps);
-    const out = h.out.join("");
-    expect(out).toContain(`${"x".repeat(59)}…`);
-    expect(out).not.toContain(long);
-  });
-});
-
-describe("terminal safety", () => {
-  it("refuses to print a download to a terminal", async () => {
-    const h = harness(
-      { ASTEROID_API_KEY: "sk_test" },
-      () => new Response("bytes"),
-    );
-    h.deps.stdoutIsTTY = true;
-    expect(await run(["execution", "recording", "e1"], h.deps)).toBe(2);
-    expect(h.err.join("")).toContain("--output");
-  });
-
-  it("cleans control characters out of API errors", async () => {
-    const h = harness({ ASTEROID_API_KEY: "sk_test" }, () =>
-      json({ detail: "bad\u001b[2Jthing" }, 400),
-    );
-    await run(["execution", "get", "e1"], h.deps);
-    expect(h.err.join("")).toContain("badthing");
-    expect(h.err.join("")).not.toContain("\u001b");
-  });
-
-  it("fills a body organization from an API key's whoami", async () => {
-    const h = harness({ ASTEROID_API_KEY: "sk_test" }, (call) =>
-      call.url.endsWith("/users/v2/whoami")
-        ? json({ organizationId: "org-from-key" })
-        : json({ id: "w1" }),
-    );
-    expect(await run(["workflow", "create", "--name", "W"], h.deps)).toBe(0);
-    expect(JSON.parse(String(h.calls.at(-1)!.init.body))).toMatchObject({
-      organizationId: "org-from-key",
-      name: "W",
-    });
-  });
-});
-
-describe("files --out", () => {
-  it("writes a pinned version into the folder it is given", async () => {
-    const h = harness({ ASTEROID_API_KEY: "sk_test" }, () =>
-      json({
-        rev: 1,
-        version: 2,
-        versionId: "v-2",
-        workflowName: "Fill form",
-        files: [
-          {
-            path: "settings.yaml",
-            kind: "structural",
-            size: 3,
-            content: "a: 1",
-          },
-        ],
-      }),
-    );
-    const dir = join(h.configDir, "pulled");
-
-    const code = await run(
-      ["workflow", "version", "pull", "w1", "v-2", "--out", dir],
-      h.deps,
-    );
-
-    expect(code).toBe(0);
-    expect(h.calls[0].url).toBe(
-      "https://odyssey.asteroid.ai/agents/v2/workflows/w1/versions/v-2/files?contents=all",
-    );
-    expect(readFileSync(join(dir, "settings.yaml"), "utf8")).toBe("a: 1");
-  });
-});
-
-describe("workflow pull and push", () => {
-  const tree = {
-    rev: 1,
-    version: 2,
-    versionId: "v-2",
-    workflowName: "Fill form",
-    files: [
-      { path: "settings.yaml", kind: "structural", size: 4, content: "a: 1" },
-    ],
-  };
-
-  it("pulls into ./<workflow-name>/head and pushes from there with no arguments", async () => {
-    const h = harness({ ASTEROID_API_KEY: "sk_test" }, (call) =>
-      call.init.method === "PATCH" ? json({}) : json({ ...tree, rev: 2 }),
-    );
-
-    expect(await run(["workflow", "pull", "w1"], h.deps)).toBe(0);
-    const head = join(h.configDir, "Fill_form", "head");
-    expect(readFileSync(join(head, "settings.yaml"), "utf8")).toBe("a: 1");
-
-    writeFileSync(join(head, "settings.yaml"), "a: 2");
-    const code = await run(["workflow", "push"], { ...h.deps, cwd: head });
-
-    expect(code).toBe(0);
-    const patch = h.calls.find((call) => call.init.method === "PATCH")!;
-    expect(patch.url).toBe(
-      "https://odyssey.asteroid.ai/agents/v2/workflows/w1/head/files",
-    );
-    expect(JSON.parse(String(patch.init.body))).toMatchObject({ baseRev: 2 });
-  });
-
-  it("pushes the folder --from names, taking the workflow from its manifest", async () => {
-    const h = harness({ ASTEROID_API_KEY: "sk_test" }, (call) =>
-      call.init.method === "PATCH" ? json({}) : json({ ...tree, rev: 2 }),
-    );
-    await run(["workflow", "pull", "w9"], h.deps);
-    const head = join(h.configDir, "Fill_form", "head");
-    writeFileSync(join(head, "settings.yaml"), "a: 3");
-
-    const code = await run(["workflow", "push", "--from", head], h.deps);
-
-    expect(code).toBe(0);
-    const patch = h.calls.find((call) => call.init.method === "PATCH")!;
-    expect(patch.url).toBe(
-      "https://odyssey.asteroid.ai/agents/v2/workflows/w9/head/files",
-    );
-  });
-});
-
-describe("workflow pull with a filter", () => {
-  it("refuses a partial tree, which would delete the files it leaves out", async () => {
-    const h = harness({ ASTEROID_API_KEY: "sk_test" }, () => json({}));
-
-    const code = await run(
-      ["workflow", "pull", "w1", "--paths", "a.md"],
-      h.deps,
-    );
-
-    expect(code).toBe(2);
-    expect(h.calls).toEqual([]);
-    expect(h.err.join("")).toContain("cannot take --paths");
-  });
-});
-
-describe("reference", () => {
-  it("matches the generated agent-docs page", () => {
-    const page = readFileSync(
-      new URL("../../../docs/cli/reference.mdx", import.meta.url),
-      "utf8",
-    );
-    expect(page).toBe(renderReference(ALL_COMMANDS));
-  });
-});