@taqueria/plugin-tezbox 0.61.4

package/index.js

@@ -0,0 +1,720 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// index.ts
+var import_node_sdk3 = require("@taqueria/node-sdk");
+
+// proxy.ts
+var import_node_sdk2 = require("@taqueria/node-sdk");
+var import_signer = require("@taquito/signer");
+var import_bignumber = __toESM(require("bignumber.js"));
+var bip39 = __toESM(require("bip39"));
+var import_crypto = require("crypto");
+var fs = __toESM(require("fs"));
+var hjson = __toESM(require("hjson"));
+var path = __toESM(require("path"));
+
+// docker.ts
+var import_node_sdk = require("@taqueria/node-sdk");
+var getDefaultDockerImage = (opts) => `ghcr.io/tez-capital/tezbox:tezos-v20.3.20241003`;
+
+// proxy.ts
+var logger = {
+  info: (message) => console.log(message),
+  warn: (message) => console.warn(message),
+  error: (message) => console.error(message)
+};
+function getErrorMessage(prefix, error) {
+  if (prefix === "") {
+    return error instanceof Error ? error.message : String(error);
+  }
+  if (typeof error === "boolean") {
+    return `${prefix}:`;
+  }
+  const errorString = error instanceof Error ? error.message : String(error);
+  return `${prefix}: ${errorString}`;
+}
+async function runCommand(cmd, stderrHandler) {
+  try {
+    const { stdout, stderr } = await (0, import_node_sdk2.execCmd)(cmd);
+    if (stderr.trim()) {
+      if (stderrHandler) {
+        await stderrHandler(stderr.trim());
+      } else {
+        throw new Error(stderr.trim());
+      }
+    }
+    return { stdout };
+  } catch (error) {
+    throw new Error(getErrorMessage(`Command failed`, error));
+  }
+}
+function isTezBoxEnvironment(taskArgs) {
+  const environment = taskArgs.config.environment[taskArgs.env];
+  if (!environment || typeof environment !== "object") return false;
+  const sandboxes = environment.sandboxes;
+  if (!Array.isArray(sandboxes) || sandboxes.length === 0) return false;
+  return true;
+}
+async function instantiateDeclaredAccount(declaredAccountName, balanceInMutez) {
+  logger.warn(`instantiateDeclaredAccount is not implemented. Returning dummy data for ${declaredAccountName}.`);
+  return {
+    encryptedKey: "unencrypted:edpktdummykey123",
+    publicKeyHash: `tz1_dummy_public_key_hash_${declaredAccountName}`,
+    secretKey: "unencrypted:edskdummysecretkey123"
+  };
+}
+async function getInstantiatedAccounts(taskArgs) {
+  const sandboxConfig = getSandboxConfig(taskArgs);
+  if (!sandboxConfig.accounts) {
+    throw new Error("No instantiated accounts found in sandbox config.");
+  }
+  const accounts = sandboxConfig.accounts;
+  return Object.entries(accounts).filter(([key]) => key !== "default").reduce((acc, [key, value]) => {
+    acc[key] = value;
+    return acc;
+  }, {});
+}
+function getSandboxConfig(taskArgs) {
+  var _a, _b;
+  if (!isTezBoxEnvironment(taskArgs)) {
+    throw new Error(
+      `This configuration doesn't appear to be configured to use TezBox environments. Check the ${taskArgs.env} environment in your .taq/config.json.`
+    );
+  }
+  const environment = taskArgs.config.environment[taskArgs.env];
+  const sandboxName = (_a = environment.sandboxes) == null ? void 0 : _a[0];
+  if (sandboxName) {
+    const sandboxConfig = (_b = taskArgs.config.sandbox) == null ? void 0 : _b[sandboxName];
+    if (sandboxConfig) {
+      const retval = {
+        blockTime: 1,
+        baking: "enabled" /* ENABLED */,
+        ...sandboxConfig,
+        ...sandboxConfig.annotations
+      };
+      return retval;
+    }
+  }
+  throw new Error(`No sandbox configuration found for ${taskArgs.env} environment.`);
+}
+async function getOrCreateInstantiatedAccounts(taskArgs) {
+  let instantiatedAccounts;
+  try {
+    instantiatedAccounts = await getInstantiatedAccounts(taskArgs);
+  } catch (error) {
+    instantiatedAccounts = {};
+    const declaredAccounts = taskArgs.config.accounts;
+    for (const [accountName, balanceInMutez] of Object.entries(declaredAccounts)) {
+      const balanceInMutezBN = new import_bignumber.default(balanceInMutez.toString().replace(/_/g, ""));
+      const instantiatedAccount = await instantiateDeclaredAccount(accountName, balanceInMutezBN);
+      instantiatedAccounts[accountName] = instantiatedAccount;
+    }
+    await saveInstantiatedAccounts(instantiatedAccounts, taskArgs.projectDir, taskArgs.env);
+  }
+  return instantiatedAccounts;
+}
+async function saveInstantiatedAccounts(accounts, projectDir, env) {
+  const configPath = path.join(projectDir, `.taq/config.local.${env}.json`);
+  try {
+    let config = {};
+    try {
+      const configContent = await fs.promises.readFile(configPath, "utf8");
+      config = JSON.parse(configContent);
+    } catch (error) {
+    }
+    const sandboxAccounts = {};
+    for (const [name, account] of Object.entries(accounts)) {
+      sandboxAccounts[name] = {
+        publicKeyHash: account.publicKeyHash,
+        secretKey: account.secretKey
+      };
+    }
+    config.accounts = sandboxAccounts;
+    await fs.promises.mkdir(path.dirname(configPath), { recursive: true });
+    await fs.promises.writeFile(configPath, JSON.stringify(config, null, 2), "utf8");
+  } catch (error) {
+    throw new Error(getErrorMessage("Failed to save instantiated accounts", error));
+  }
+}
+async function getPublicKeyFromSecretKey(secretKey) {
+  const signer = await import_signer.InMemorySigner.fromSecretKey(secretKey.replace("unencrypted:", ""));
+  const publicKey = await signer.publicKey();
+  return publicKey;
+}
+async function prepareTezBoxAccounts(instantiatedAccounts, declaredAccounts) {
+  const tezboxAccounts = {};
+  for (const [accountName, accountData] of Object.entries(instantiatedAccounts)) {
+    if (accountName === "default") continue;
+    const secretKey = accountData.secretKey;
+    tezboxAccounts[accountName] = {
+      pkh: accountData.publicKeyHash,
+      pk: await getPublicKeyFromSecretKey(secretKey),
+      sk: secretKey,
+      balance: accountName === "funder" ? new import_bignumber.default(1e14).toString() : new import_bignumber.default(declaredAccounts[accountName].toString()).toString()
+    };
+  }
+  return tezboxAccounts;
+}
+async function writeAccountsHjson(tezboxAccounts, tezBoxConfigDir) {
+  await Promise.resolve();
+  const hjsonContent = hjson.stringify(tezboxAccounts, {
+    quotes: "min",
+    bracesSameLine: true,
+    separator: false
+  });
+  const fixedHjsonContent = hjsonContent.replaceAll('"', "");
+  const accountsHjsonPath = path.join(tezBoxConfigDir, "accounts.hjson");
+  await fs.promises.writeFile(accountsHjsonPath, fixedHjsonContent, "utf8");
+}
+function getDeclaredAccounts(taskArgs) {
+  const declaredAccounts = taskArgs.config.accounts;
+  return Object.entries(declaredAccounts).reduce((acc, [key, value]) => {
+    acc[key] = value.toString().replace(/_/g, "");
+    return acc;
+  }, {});
+}
+async function prepareAccountsHjson(taskArgs, tezBoxConfigDir) {
+  try {
+    const instantiatedAccounts = await getOrCreateInstantiatedAccounts(taskArgs);
+    const declaredAccounts = getDeclaredAccounts(taskArgs);
+    const tezboxAccounts = await prepareTezBoxAccounts(instantiatedAccounts, declaredAccounts);
+    await writeAccountsHjson(tezboxAccounts, tezBoxConfigDir);
+  } catch (error) {
+    throw new Error(getErrorMessage(`Failed to prepare accounts`, error));
+  }
+}
+async function prepareBakersHjson(taskArgs, tezBoxConfigDir) {
+  try {
+    const declaredAccounts = getDeclaredAccounts(taskArgs);
+    const totalBalance = Object.values(declaredAccounts).reduce(
+      (sum, balance) => import_bignumber.default.sum(sum, balance),
+      new import_bignumber.default(0)
+    ).toString();
+    const bakers = {
+      baker1: {
+        pkh: "tz1faswCTDciRzE4oJ9jn2Vm2dvjeyA9fUzU",
+        pk: "edpkuTXkJDGcFd5nh6VvMz8phXxU3Bi7h6hqgywNFi1vZTfQNnS1RV",
+        sk: "unencrypted:edsk4ArLQgBTLWG5FJmnGnT689VKoqhXwmDPBuGx3z4cvwU9MmrPZZ",
+        balance: totalBalance
+      },
+      baker2: {
+        pkh: "tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN",
+        pk: "edpktzNbDAUjUk697W7gYg2CRuBQjyPxbEg8dLccYYwKSKvkPvjtV9",
+        sk: "unencrypted:edsk39qAm1fiMjgmPkw1EgQYkMzkJezLNewd7PLNHTkr6w9XA2zdfo",
+        balance: totalBalance
+      },
+      baker3: {
+        pkh: "tz1b7tUupMgCNw2cCLpKTkSD1NZzB5TkP2sv",
+        pk: "edpkuFrRoDSEbJYgxRtLx2ps82UdaYc1WwfS9sE11yhauZt5DgCHbU",
+        sk: "unencrypted:edsk2uqQB9AY4FvioK2YMdfmyMrer5R8mGFyuaLLFfSRo8EoyNdht3",
+        balance: totalBalance
+      }
+    };
+    const hjsonContent = hjson.stringify(bakers, {
+      quotes: "min",
+      bracesSameLine: true,
+      separator: false
+    });
+    const fixedHjsonContent = hjsonContent.replaceAll('"', "");
+    const bakersHjsonPath = path.join(tezBoxConfigDir, "bakers.hjson");
+    await fs.promises.writeFile(bakersHjsonPath, fixedHjsonContent, "utf8");
+  } catch (error) {
+    throw new Error(getErrorMessage(`Failed to prepare bakers`, error));
+  }
+}
+function getProjectId(taskArgs) {
+  return (0, import_crypto.createHash)("sha256").update(taskArgs.projectDir).digest("hex");
+}
+function getDockerContainerName(taskArgs) {
+  const projectId = getProjectId(taskArgs);
+  return `taq-${taskArgs.env}-${projectId}`;
+}
+function getTezBoxConfigDir(taskArgs) {
+  const containerName = getDockerContainerName(taskArgs);
+  return path.join(taskArgs.projectDir, `.taq/.${containerName}/config`);
+}
+function getTezBoxDataDir(taskArgs) {
+  const containerName = getDockerContainerName(taskArgs);
+  return path.join(taskArgs.projectDir, `.taq/.${containerName}/data`);
+}
+function getImage(taskArgs) {
+  return (0, import_node_sdk2.getDockerImage)(getDefaultDockerImage(taskArgs), "TAQ_TEZBOX_IMAGE");
+}
+async function isSandboxRunning(taskArgs) {
+  const containerName = getDockerContainerName(taskArgs);
+  const cmd = `docker ps --filter "name=${containerName}" --format "{{.ID}}"`;
+  const { stdout } = await runCommand(cmd);
+  return stdout.trim() !== "";
+}
+async function checkSandboxRunning(taskArgs) {
+  const running = await isSandboxRunning(taskArgs);
+  if (running) {
+    await (0, import_node_sdk2.sendAsyncRes)("Sandbox is already running.");
+  }
+  return running;
+}
+function getPortNumber(taskArgs) {
+  const rpcUrl = getSandboxConfig(taskArgs).rpcUrl;
+  const match = rpcUrl.match(/:(\d+)/);
+  return match ? parseInt(match[1], 10) : 80;
+}
+function getContainerPort(taskArgs) {
+  return getPortNumber(taskArgs) + 1;
+}
+async function getDockerRunParams(taskArgs) {
+  const image = getImage(taskArgs);
+  const containerName = getDockerContainerName(taskArgs);
+  const platform = await (0, import_node_sdk2.getArch)();
+  const configDir = getTezBoxConfigDir(taskArgs);
+  const dataDir = getTezBoxDataDir(taskArgs);
+  const port = getContainerPort(taskArgs);
+  return { platform, image, containerName, configDir, dataDir, port };
+}
+async function ensureDirectoriesExist(directories) {
+  await Promise.all(
+    directories.map((dir) => fs.promises.mkdir(dir, { recursive: true }))
+  );
+}
+function constructDockerRunCommand(params) {
+  const { platform, image, containerName, configDir, port } = params;
+  const dockerOptions = [
+    "docker run",
+    "-d",
+    `--platform ${platform}`,
+    "-p 8732:8732",
+    `-p ${port}:20000`,
+    `--name ${containerName}`,
+    `-v "${configDir}:/tezbox/overrides"`,
+    image
+    // 'qenabox', // TODO: restore once working upstream
+  ];
+  return dockerOptions.join(" ");
+}
+function validateBlockTime(taskArgs) {
+  const sandboxConfig = getSandboxConfig(taskArgs);
+  const blockTime = sandboxConfig.blockTime;
+  if (blockTime === void 0 || blockTime === null) {
+    logger.warn("Block time is not specified; skipping block_time override.");
+    return null;
+  }
+  return blockTime;
+}
+async function writeSandboxParameters(protocolId, parameters, tezBoxConfigDir) {
+  const protocolsDir = path.join(tezBoxConfigDir, "protocols", protocolId);
+  await fs.promises.mkdir(protocolsDir, { recursive: true });
+  const hjsonContent = hjson.stringify(parameters, {
+    quotes: "min",
+    bracesSameLine: true,
+    separator: false
+  });
+  const sandboxParamsPath = path.join(protocolsDir, "sandbox-parameters.hjson");
+  await fs.promises.writeFile(sandboxParamsPath, hjsonContent, "utf8");
+  try {
+    await fs.promises.chmod(sandboxParamsPath, 420);
+  } catch (error) {
+    logger.warn(getErrorMessage(`Failed to set file permissions for ${sandboxParamsPath}`, error));
+  }
+}
+async function applyBlockTimeOverrideToProtocol(protocolId, blockTime, tezBoxConfigDir) {
+  const nonce_revelation_threshold = 16;
+  const minimal_block_delay = blockTime;
+  const parameters = {
+    minimal_block_delay: minimal_block_delay.toString()
+  };
+  await writeSandboxParameters(protocolId, parameters, tezBoxConfigDir);
+}
+async function applyBlockTimeOverrideToProtocols(protocolIds, blockTime, tezBoxConfigDir) {
+  await Promise.all(
+    protocolIds.map(async (protocolId) => {
+      if (/^alpha$/i.test(protocolId)) {
+        return;
+      }
+      await applyBlockTimeOverrideToProtocol(protocolId, blockTime, tezBoxConfigDir);
+    })
+  );
+}
+async function getProtocolIds(taskArgs) {
+  const image = getImage(taskArgs);
+  const cmd = `docker run --rm --entrypoint ls ${image} /tezbox/configuration/protocols`;
+  const { stdout } = await runCommand(cmd);
+  const protocolIds = stdout.trim().split("\n").map((line) => line.trim()).filter((line) => line !== "");
+  return protocolIds;
+}
+async function readProtocolJson(image, protocolId) {
+  const cmd = `docker run --rm --entrypoint cat ${image} /tezbox/configuration/protocols/${protocolId}/protocol.hjson`;
+  try {
+    const { stdout } = await runCommand(cmd);
+    if (!stdout.trim()) {
+      logger.warn(`protocol.hjson not found or empty for protocolId ${protocolId}; skipping this protocol.`);
+      return null;
+    }
+    const protocolData = hjson.parse(stdout);
+    const protocolHash = protocolData.hash;
+    if (protocolHash) {
+      return { id: protocolId, hash: protocolHash };
+    } else {
+      logger.warn(`Protocol hash not found in protocol.hjson for protocolId ${protocolId}; skipping.`);
+      return null;
+    }
+  } catch (error) {
+    logger.warn(getErrorMessage(`Failed to read protocol.hjson for protocolId ${protocolId}`, error));
+    return null;
+  }
+}
+async function getProtocolMappings(taskArgs) {
+  const image = getImage(taskArgs);
+  const protocolIds = await getProtocolIds(taskArgs);
+  const protocolMappingsPromises = protocolIds.map(async (protocolId) => {
+    const mapping = await readProtocolJson(image, protocolId);
+    return mapping;
+  });
+  const protocolMappings = await Promise.all(protocolMappingsPromises);
+  return protocolMappings.filter((mapping) => mapping !== null);
+}
+async function getOctezClientProtocols(taskArgs) {
+  const image = getImage(taskArgs);
+  const cmd = `docker run --rm --entrypoint octez-client ${image} -M mockup list mockup protocols`;
+  const { stdout } = await runCommand(cmd, (stderr) => {
+    const ignorableError = "Base directory /tezbox/data/.tezos-client does not exist.";
+    if (stderr.trim() !== "" && !stderr.includes(ignorableError)) {
+      throw new Error(`Failed to list protocols: ${stderr.trim()}`);
+    }
+  });
+  const protocols = stdout.trim().split("\n").filter((line) => line.trim() !== "");
+  return protocols;
+}
+async function prepareSandboxParametersHjson(taskArgs, tezBoxConfigDir) {
+  try {
+    const blockTime = validateBlockTime(taskArgs);
+    if (blockTime === null) {
+      return;
+    }
+    const protocolMappings = await getProtocolMappings(taskArgs);
+    const hashToIdMap = {};
+    for (const mapping of protocolMappings) {
+      hashToIdMap[mapping.hash] = mapping.id;
+    }
+    const protocolHashes = await getOctezClientProtocols(taskArgs);
+    const protocolIdsToOverride = protocolHashes.map((hash) => hashToIdMap[hash]).filter((id) => id !== void 0);
+    if (protocolIdsToOverride.length === 0) {
+      logger.warn("No matching protocol IDs found; cannot set block_time override.");
+      return;
+    }
+    await applyBlockTimeOverrideToProtocols(protocolIdsToOverride, blockTime, tezBoxConfigDir);
+  } catch (error) {
+    const errorMessage = getErrorMessage(`Failed to prepare sandbox parameters:`, error);
+    throw new Error(errorMessage);
+  }
+}
+async function prepareBakerHjson(tezBoxConfigDir) {
+  const servicesDir = path.join(tezBoxConfigDir, "services");
+  try {
+    await fs.promises.mkdir(servicesDir, { recursive: true });
+    const bakerConfig = {
+      autostart: false
+    };
+    const hjsonContent = hjson.stringify(bakerConfig, {
+      quotes: "all",
+      bracesSameLine: true,
+      separator: true
+    });
+    const bakerConfigPath = path.join(servicesDir, "baker.hjson");
+    await fs.promises.writeFile(bakerConfigPath, hjsonContent, "utf8");
+  } catch (error) {
+    throw new Error(getErrorMessage(`Failed to prepare baker.hjson`, error));
+  }
+}
+async function prepareTezBoxOverrides(taskArgs) {
+  const tezBoxConfigDir = getTezBoxConfigDir(taskArgs);
+  try {
+    const sandboxConfig = getSandboxConfig(taskArgs);
+    await fs.promises.mkdir(tezBoxConfigDir, { recursive: true });
+    const tasks = [];
+    tasks.push(prepareBakersHjson(taskArgs, tezBoxConfigDir));
+    if (taskArgs.config.accounts) {
+      tasks.push(prepareAccountsHjson(taskArgs, tezBoxConfigDir));
+    }
+    if (sandboxConfig.blockTime) {
+      tasks.push(prepareSandboxParametersHjson(taskArgs, tezBoxConfigDir));
+    }
+    if (sandboxConfig.baking === "disabled" /* DISABLED */) {
+      tasks.push(prepareBakerHjson(tezBoxConfigDir));
+    }
+    await Promise.all(tasks);
+  } catch (error) {
+    throw new Error(getErrorMessage(`Failed to prepare TezBox overrides`, error));
+  }
+}
+function getProxyContainerName(taskArgs) {
+  return `${getDockerContainerName(taskArgs)}-proxy`;
+}
+async function startProxyServer(taskArgs) {
+  const containerPort = getContainerPort(taskArgs);
+  const proxyPort = getPortNumber(taskArgs);
+  const proxyContainerName = getProxyContainerName(taskArgs);
+  const proxyCmd = `docker run -d --name ${proxyContainerName}         --network host         caddy:2-alpine         caddy reverse-proxy         --from http://:${proxyPort}         --to http://127.0.0.1:${containerPort}         --access-log`;
+  try {
+    await runCommand(proxyCmd);
+  } catch (error) {
+    throw new Error(getErrorMessage(`Failed to start Caddy reverse proxy`, error));
+  }
+}
+async function stopProxyServer(taskArgs) {
+  const proxyContainerName = getProxyContainerName(taskArgs);
+  const cmd = `docker rm -f ${proxyContainerName}`;
+  await runCommand(cmd);
+}
+async function startSandbox(taskArgs) {
+  try {
+    await checkDockerAvailability();
+    if (await checkSandboxRunning(taskArgs)) {
+      return;
+    }
+    const params = await getDockerRunParams(taskArgs);
+    await ensureDirectoriesExist([params.dataDir, params.configDir]);
+    await prepareTezBoxOverrides(taskArgs);
+    const cmd = constructDockerRunCommand(params);
+    await runCommand(cmd);
+    await startProxyServer(taskArgs);
+    await (0, import_node_sdk2.sendAsyncRes)("Sandbox started successfully.");
+  } catch (error) {
+    await (0, import_node_sdk2.sendAsyncErr)(getErrorMessage(`Failed to start sandbox`, error));
+  }
+}
+async function checkDockerAvailability() {
+  try {
+    await runCommand("docker --version");
+  } catch (error) {
+    throw new Error("Docker is not installed or not running. Please install and start Docker.");
+  }
+}
+async function removeSandboxContainer(taskArgs) {
+  const containerName = getDockerContainerName(taskArgs);
+  const cmd = `docker rm -f ${containerName}`;
+  try {
+    await runCommand(cmd);
+  } catch (error) {
+    const errorMessage = getErrorMessage("", error);
+    if (errorMessage.includes("No such container")) {
+      await (0, import_node_sdk2.sendAsyncRes)("Sandbox is not running or already stopped.");
+    } else {
+      throw new Error(errorMessage);
+    }
+  }
+  await stopProxyServer(taskArgs);
+}
+async function stopSandbox(taskArgs) {
+  try {
+    await removeSandboxContainer(taskArgs);
+    const configDir = getTezBoxConfigDir(taskArgs);
+    await fs.promises.rm(configDir, { recursive: true, force: true });
+    await (0, import_node_sdk2.sendAsyncRes)("Sandbox stopped and cleaned up.");
+  } catch (error) {
+    await (0, import_node_sdk2.sendAsyncErr)(getErrorMessage(`Failed to stop sandbox`, error));
+  }
+}
+async function restartSandbox(taskArgs) {
+  try {
+    await removeSandboxContainer(taskArgs);
+    await startSandbox(taskArgs);
+    await (0, import_node_sdk2.sendAsyncRes)("Sandbox restarted successfully.");
+  } catch (error) {
+    await (0, import_node_sdk2.sendAsyncErr)(getErrorMessage(`Failed to restart sandbox`, error));
+  }
+}
+async function listProtocols(taskArgs) {
+  try {
+    const protocolHashes = await getOctezClientProtocols(taskArgs);
+    const protocolObjects = protocolHashes.map((protocol) => ({ protocol }));
+    await (0, import_node_sdk2.sendAsyncJsonRes)(protocolObjects);
+  } catch (error) {
+    await (0, import_node_sdk2.sendAsyncErr)(getErrorMessage(`Failed to list protocols`, error));
+  }
+}
+async function listAccounts(taskArgs) {
+  try {
+    if (await isSandboxRunning(taskArgs)) {
+      const containerName = getDockerContainerName(taskArgs);
+      const cmd = `docker exec ${containerName} octez-client list known addresses`;
+      const { stdout } = await runCommand(cmd);
+      if (!stdout.trim()) {
+        await (0, import_node_sdk2.sendAsyncRes)("No accounts found.");
+        return;
+      }
+      const accounts = stdout.trim().split("\n").filter((line) => line.trim() !== "").map((line) => {
+        const [name, rest] = line.split(":");
+        const address = rest ? rest.trim().split(" ")[0] : "";
+        return { name: name.trim(), address };
+      });
+      await (0, import_node_sdk2.sendAsyncJsonRes)(accounts);
+    } else {
+      await (0, import_node_sdk2.sendAsyncErr)(`Sandbox is not running. Please start the sandbox before attempting to list accounts.`);
+    }
+  } catch (error) {
+    await (0, import_node_sdk2.sendAsyncErr)(getErrorMessage(`Failed to list accounts`, error));
+  }
+}
+async function bakeBlock(taskArgs) {
+  try {
+    if (await isSandboxRunning(taskArgs)) {
+      const containerName = getDockerContainerName(taskArgs);
+      const cmd = `docker exec ${containerName} octez-client bake for baker1`;
+      if (taskArgs.watch) {
+        console.log("Baking on demand as operations are injected.");
+        console.log("Press CTRL-C to stop and exit.");
+        console.log();
+        while (true) {
+          console.log("Waiting for operations to be injected...");
+          while (true) {
+            const { stdout } = await runCommand(
+              `docker exec ${containerName} octez-client rpc get /chains/main/mempool/pending_operations`
+            );
+            const ops = JSON.parse(stdout);
+            if (Array.isArray(ops.applied) && ops.applied.length > 0) break;
+            await new Promise((resolve) => setTimeout(resolve, 1e3));
+          }
+          await runCommand(cmd);
+          console.log("Block baked.");
+        }
+      } else {
+        await runCommand(cmd);
+        await (0, import_node_sdk2.sendAsyncRes)("Block baked successfully.");
+      }
+    } else {
+      try {
+        await (0, import_node_sdk2.sendAsyncErr)("Sandbox is not running. Please start the sandbox before attempting to bake a block.");
+      } catch {
+      }
+    }
+  } catch (error) {
+    await (0, import_node_sdk2.sendAsyncErr)(getErrorMessage(`Failed to bake block`, error));
+  }
+}
+var proxy = async (taskArgs) => {
+  var _a;
+  if (!isTezBoxEnvironment(taskArgs)) {
+    await (0, import_node_sdk2.sendAsyncErr)(
+      `This configuration doesn't appear to be configured to use TezBox environments. Check the ${taskArgs.env} environment in your .taq/config.json.`
+    );
+    return;
+  }
+  const taskName = (_a = taskArgs.task) == null ? void 0 : _a.toLowerCase().trim();
+  const taskHandlers = {
+    "start sandbox": startSandbox,
+    "stop sandbox": stopSandbox,
+    "restart sandbox": restartSandbox,
+    "list protocols": listProtocols,
+    "list-protocols": listProtocols,
+    "show protocols": listProtocols,
+    "show-protocols": listProtocols,
+    "list accounts": listAccounts,
+    "list-accounts": listAccounts,
+    "show accounts": listAccounts,
+    "show-accounts": listAccounts,
+    "bake": bakeBlock,
+    "bake block": bakeBlock
+  };
+  const handler = taskName ? taskHandlers[taskName] : void 0;
+  if (handler) {
+    try {
+      await handler(taskArgs);
+    } catch (error) {
+      await (0, import_node_sdk2.sendAsyncErr)(getErrorMessage(`Error executing task '${taskArgs.task}'`, error));
+    }
+  } else {
+    await (0, import_node_sdk2.sendAsyncErr)(taskArgs.task ? `Unknown task: ${taskArgs.task}` : "No task provided");
+  }
+};
+var proxy_default = proxy;
+
+// index.ts
+import_node_sdk3.Plugin.create((_i18n) => ({
+  alias: "tezbox",
+  schema: "1.0",
+  version: "0.1",
+  tasks: [
+    import_node_sdk3.Task.create({
+      task: "start sandbox",
+      command: "start sandbox",
+      aliases: ["start tezbox"],
+      description: "Starts a TezBox sandbox",
+      options: [],
+      handler: "proxy",
+      encoding: "none"
+    }),
+    import_node_sdk3.Task.create({
+      task: "stop sandbox",
+      command: "stop sandbox",
+      aliases: ["stop tezbox"],
+      description: "Stops a TezBox sandbox",
+      options: [],
+      handler: "proxy"
+    }),
+    import_node_sdk3.Task.create({
+      task: "restart sandbox",
+      command: "restart sandbox",
+      aliases: ["restart tezbox"],
+      description: "Restarts a TezBox sandbox",
+      options: [],
+      handler: "proxy"
+    }),
+    import_node_sdk3.Task.create({
+      task: "list accounts",
+      command: "list accounts",
+      aliases: [],
+      description: "List the balances of all sandbox accounts",
+      options: [],
+      handler: "proxy",
+      encoding: "json"
+    }),
+    import_node_sdk3.Task.create({
+      task: "bake",
+      command: "bake",
+      aliases: ["b"],
+      description: 'Manually bake a block. Use when the "baking" setting of a TezBox sandbox is set to "disabled".',
+      options: [
+        import_node_sdk3.Option.create({
+          flag: "watch",
+          shortFlag: "w",
+          description: "Watch for operations as they are injected into the mempool and bake them as immediate as possible.",
+          boolean: true
+        })
+      ],
+      handler: "proxy",
+      encoding: "none"
+    }),
+    import_node_sdk3.Task.create({
+      task: "show protocols",
+      command: "show protocols",
+      aliases: ["list protocols"],
+      description: "List protocols understood by this version of TezBox",
+      options: [],
+      handler: "proxy",
+      encoding: "json"
+    })
+  ],
+  proxy: proxy_default
+}), process.argv);
+//# sourceMappingURL=index.js.map