@eagsolutions/phanom-cli 0.0.1

package/bin/phanom.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "../src/index.js";

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@eagsolutions/phanom-cli",
+  "version": "0.0.1",
+  "description": "PhanomCloud CLI",
+  "type": "module",
+  "bin": {
+    "phanom": "bin/phanom.js"
+  },
+  "scripts": {
+    "start": "node bin/phanom.js"
+  },
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "inquirer": "^9.3.7"
+  }
+}

package/src/commands/init.js

@@ -0,0 +1,28 @@
+import inquirer from "inquirer";
+import fs from "fs";
+import os from "os";
+import path from "path";
+import chalk from "chalk";
+
+export default async function init() {
+  const promptText =
+    chalk.black("(") +
+    chalk.gray(" @") +
+    chalk.black(" ) ") +
+    chalk.gray("API key: ") +
+    chalk.white("");
+
+  const answers = await inquirer.prompt([
+    {
+      type: "password",
+      name: "apikey",
+      message: promptText,
+      mask: "*"
+    }
+  ]);
+
+  const rcPath = path.join(os.homedir(), ".openphanomid.rc");
+  const content = `API=${answers.apikey}\n`;
+
+  fs.writeFileSync(rcPath, content, "utf8");
+}

package/src/commands/logs.js

@@ -0,0 +1,100 @@
+import chalk from "chalk";
+import { getApiKey } from "../utils/config.js";
+
+export default async function logs(name, options) {
+  const apiKey = getApiKey();
+
+  const botsResponse = await fetch(
+    "https://api.phanomcloud.online/bots",
+    {
+      headers: {
+        Authorization: `Bearer ${apiKey}`
+      }
+    }
+  );
+
+  if (!botsResponse.ok) {
+    console.log(
+      chalk.red("Failed to fetch bots.")
+    );
+    process.exit(1);
+  }
+
+  const botsJson = await botsResponse.json();
+
+  if (!botsJson.success) {
+    console.log(
+      chalk.red("Invalid API response.")
+    );
+    process.exit(1);
+  }
+
+  const bot = botsJson.data.find(
+    (b) =>
+      b.name.toLowerCase() ===
+      name.toLowerCase()
+  );
+
+  if (!bot) {
+    console.log(
+      chalk.red(`Bot "${name}" not found.`)
+    );
+    process.exit(1);
+  }
+
+  let url =
+    `https://api.phanomcloud.online/bots/${bot.id}/logs`;
+
+  if (options.lines) {
+    url += `?lines=${options.lines}`;
+  }
+
+  const logsResponse = await fetch(url, {
+    headers: {
+      Authorization: `Bearer ${apiKey}`
+    }
+  });
+
+  if (!logsResponse.ok) {
+    console.log(
+      chalk.red("Failed to fetch logs.")
+    );
+    process.exit(1);
+  }
+
+  const logsJson = await logsResponse.json();
+
+  if (!logsJson.success) {
+    console.log(
+      chalk.red("Invalid logs response.")
+    );
+    process.exit(1);
+  }
+
+  const logs = logsJson.data.logs || [];
+
+  if (!logs.length) {
+    console.log(
+      chalk.gray("No logs available.")
+    );
+    return;
+  }
+
+  console.log("");
+
+  for (const line of logs) {
+    if (line.startsWith("[SYSTEM]")) {
+      console.log(
+        chalk.green(line)
+      );
+
+      continue;
+    }
+
+    console.log(
+      chalk.gray(line)
+    );
+  }
+
+  console.log("");
+}

package/src/commands/ps.js

@@ -0,0 +1,112 @@
+import chalk from "chalk";
+import { getApiKey } from "../utils/config.js";
+
+function truncate(text, max) {
+  if (!text) return "";
+  return text.length > max ? text.slice(0, max - 1) + "…" : text;
+}
+
+function pad(text, width) {
+  const str = String(text ?? "");
+  return str.length >= width ? str : str + " ".repeat(width - str.length);
+}
+
+function formatAge(createdAt) {
+  const created = new Date(createdAt);
+  const diffMs = Date.now() - created.getTime();
+
+  const mins = Math.floor(diffMs / 60000);
+  const hours = Math.floor(diffMs / 3600000);
+  const days = Math.floor(diffMs / 86400000);
+
+  if (days > 0) return `${days}d ago`;
+  if (hours > 0) return `${hours}h ago`;
+  if (mins > 0) return `${mins}m ago`;
+  return "now";
+}
+
+export default async function ps(options) {
+  const apiKey = getApiKey();
+
+  const response = await fetch("https://api.phanomcloud.online/bots", {
+    headers: {
+      Authorization: `Bearer ${apiKey}`
+    }
+  });
+
+  const json = await response.json();
+  let bots = json.data || [];
+
+  if (options.aZ) {
+    bots.sort((a, b) => a.name.localeCompare(b.name));
+  }
+
+  if (options.zA) {
+    bots.sort((a, b) => b.name.localeCompare(a.name));
+  }
+
+  if (!bots.length) {
+    console.log("No bots found.");
+    return;
+  }
+
+  const rows = bots.map((bot) => ({
+    id: bot.id.slice(0, 12),
+    name: bot.name,
+    language: bot.language,
+    status: bot.status,
+    memory: `${bot.memory}MB`,
+    vcpu: `${bot.vcpu}`,
+    age: formatAge(bot.created_at),
+    command: bot.startup_command
+  }));
+
+  const widths = {
+    id: 12,
+    name: Math.max(4, ...rows.map((r) => r.name.length)),
+    language: Math.max(8, ...rows.map((r) => r.language.length)),
+    status: Math.max(6, ...rows.map((r) => r.status.length)),
+    memory: Math.max(6, ...rows.map((r) => r.memory.length)),
+    vcpu: Math.max(4, ...rows.map((r) => r.vcpu.length)),
+    age: Math.max(6, ...rows.map((r) => r.age.length)),
+    command: Math.max(7, ...rows.map((r) => r.command.length))
+  };
+
+  console.log("");
+
+  console.log(
+    chalk.gray(
+      pad("ID", widths.id) + "  " +
+      pad("NAME", widths.name) + "  " +
+      pad("LANG", widths.language) + "  " +
+      pad("STATUS", widths.status) + "  " +
+      pad("MEMORY", widths.memory) + "  " +
+      pad("VCPU", widths.vcpu) + "  " +
+      pad("AGE", widths.age) + "  " +
+      "COMMAND"
+    )
+  );
+
+  for (const bot of rows) {
+    let statusColor = chalk.gray;
+
+    if (bot.status === "online") statusColor = chalk.green;
+    if (bot.status === "offline") statusColor = chalk.red;
+    if (bot.status === "starting") statusColor = chalk.yellow;
+    if (bot.status === "stopping") statusColor = chalk.magenta;
+    if (bot.status === "error") statusColor = chalk.redBright;
+
+    console.log(
+      chalk.white(pad(bot.id, widths.id)) + "  " +
+      chalk.white(pad(truncate(bot.name, widths.name), widths.name)) + "  " +
+      chalk.gray(pad(bot.language, widths.language)) + "  " +
+      statusColor(pad(bot.status, widths.status)) + "  " +
+      chalk.gray(pad(bot.memory, widths.memory)) + "  " +
+      chalk.gray(pad(bot.vcpu, widths.vcpu)) + "  " +
+      chalk.gray(pad(bot.age, widths.age)) + "  " +
+      chalk.gray(truncate(bot.command, widths.command))
+    );
+  }
+
+  console.log("");
+}

package/src/commands/restart.js

@@ -0,0 +1,80 @@
+import chalk from "chalk";
+import { getApiKey } from "../utils/config.js";
+
+export default async function restart(name) {
+  const apiKey = getApiKey();
+
+  const botsResponse = await fetch(
+    "https://api.phanomcloud.online/bots",
+    {
+      headers: {
+        Authorization: `Bearer ${apiKey}`
+      }
+    }
+  );
+
+  if (!botsResponse.ok) {
+    process.exit(1);
+  }
+
+  const botsJson = await botsResponse.json();
+
+  if (!botsJson.success) {
+    process.exit(1);
+  }
+
+  const bot = botsJson.data.find(
+    (b) =>
+      b.name.toLowerCase() ===
+      name.toLowerCase()
+  );
+
+  if (!bot) {
+    console.log(
+      chalk.gray("(") +
+      chalk.red("!") +
+      chalk.gray(") ") +
+      chalk.red(`Bot "${name}" not found.`)
+    );
+
+    process.exit(1);
+  }
+
+  const response = await fetch(
+    "https://api.phanomcloud.online/bots/restart",
+    {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        bot_id: bot.id
+      })
+    }
+  );
+
+  const json = await response.json();
+
+  if (!json.success) {
+    console.log(
+      chalk.gray("(") +
+      chalk.red("!") +
+      chalk.gray(") ") +
+      chalk.red(
+        json.error ||
+        "Failed to restart bot."
+      )
+    );
+
+    process.exit(1);
+  }
+
+  console.log(
+    chalk.gray("(") +
+    chalk.yellow("*") +
+    chalk.gray(") Restarted ") +
+    chalk.yellow(bot.name) +
+    chalk.gray("...")
+  );
+}

package/src/commands/shell.js

@@ -0,0 +1,156 @@
+import chalk from "chalk";
+import readline from "readline";
+
+import { getApiKey } from "../utils/config.js";
+
+export default async function shell(
+  target
+) {
+  const apiKey = getApiKey();
+
+  const botsResponse = await fetch(
+    "https://api.phanomcloud.online/bots",
+    {
+      headers: {
+        Authorization: `Bearer ${apiKey}`
+      }
+    }
+  );
+
+  if (!botsResponse.ok) {
+    process.exit(1);
+  }
+
+  const botsJson =
+    await botsResponse.json();
+
+  if (!botsJson.success) {
+    process.exit(1);
+  }
+
+  const bot = botsJson.data.find(
+    (b) =>
+      b.name.toLowerCase() ===
+        target.toLowerCase() ||
+      b.id === target
+  );
+
+  if (!bot) {
+    console.log(
+      chalk.gray("(") +
+      chalk.red("!") +
+      chalk.gray(") ") +
+      chalk.red("Bot not found.")
+    );
+
+    process.exit(1);
+  }
+
+  console.log("");
+
+  console.log(
+    chalk.gray("(") +
+    chalk.green("*") +
+    chalk.gray(") Connected to ") +
+    chalk.green(bot.name)
+  );
+
+  console.log("");
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt:
+      chalk.gray(
+        `${bot.name}`
+      ) + chalk.cyan(" ❯ ")
+  });
+
+  rl.prompt();
+
+  rl.on(
+    "line",
+    async (input) => {
+      const command =
+        input.trim();
+
+      if (!command) {
+        rl.prompt();
+        return;
+      }
+
+      if (
+        command === "exit" ||
+        command === "quit"
+      ) {
+        rl.close();
+        return;
+      }
+
+      try {
+        const response =
+          await fetch(
+            `https://api.phanomcloud.online/bots/${bot.id}/console`,
+            {
+              method: "POST",
+              headers: {
+                Authorization:
+                  `Bearer ${apiKey}`,
+                "Content-Type":
+                  "application/json"
+              },
+              body: JSON.stringify({
+                command
+              })
+            }
+          );
+
+        const json =
+          await response.json();
+
+        if (!json.success) {
+          console.log(
+            chalk.red(
+              json.error ||
+              "Command failed."
+            )
+          );
+
+          rl.prompt();
+          return;
+        }
+
+        const output =
+          json.data.output;
+
+        if (output?.trim()) {
+          console.log(
+            chalk.gray(output)
+          );
+        }
+      } catch {
+        console.log(
+          chalk.red(
+            "Failed to execute command."
+          )
+        );
+      }
+
+      rl.prompt();
+    }
+  );
+
+  rl.on("close", () => {
+    console.log("");
+
+    console.log(
+      chalk.gray("(") +
+      chalk.yellow("*") +
+      chalk.gray(") Shell closed.")
+    );
+
+    console.log("");
+
+    process.exit(0);
+  });
+}

package/src/commands/start.js

@@ -0,0 +1,80 @@
+import chalk from "chalk";
+import { getApiKey } from "../utils/config.js";
+
+export default async function start(name) {
+  const apiKey = getApiKey();
+
+  const botsResponse = await fetch(
+    "https://api.phanomcloud.online/bots",
+    {
+      headers: {
+        Authorization: `Bearer ${apiKey}`
+      }
+    }
+  );
+
+  if (!botsResponse.ok) {
+    process.exit(1);
+  }
+
+  const botsJson = await botsResponse.json();
+
+  if (!botsJson.success) {
+    process.exit(1);
+  }
+
+  const bot = botsJson.data.find(
+    (b) =>
+      b.name.toLowerCase() ===
+      name.toLowerCase()
+  );
+
+  if (!bot) {
+    console.log(
+      chalk.gray("(") +
+      chalk.red("!") +
+      chalk.gray(") ") +
+      chalk.red(`Bot "${name}" not found.`)
+    );
+
+    process.exit(1);
+  }
+
+  const response = await fetch(
+    "https://api.phanomcloud.online/bots/start",
+    {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        bot_id: bot.id
+      })
+    }
+  );
+
+  const json = await response.json();
+
+  if (!json.success) {
+    console.log(
+      chalk.gray("(") +
+      chalk.red("!") +
+      chalk.gray(") ") +
+      chalk.red(
+        json.error ||
+        "Failed to start bot."
+      )
+    );
+
+    process.exit(1);
+  }
+
+  console.log(
+    chalk.gray("(") +
+    chalk.green("*") +
+    chalk.gray(") Starting ") +
+    chalk.green(bot.name) +
+    chalk.gray("...")
+  );
+}

package/src/commands/stop.js

@@ -0,0 +1,80 @@
+import chalk from "chalk";
+import { getApiKey } from "../utils/config.js";
+
+export default async function stop(name) {
+  const apiKey = getApiKey();
+
+  const botsResponse = await fetch(
+    "https://api.phanomcloud.online/bots",
+    {
+      headers: {
+        Authorization: `Bearer ${apiKey}`
+      }
+    }
+  );
+
+  if (!botsResponse.ok) {
+    process.exit(1);
+  }
+
+  const botsJson = await botsResponse.json();
+
+  if (!botsJson.success) {
+    process.exit(1);
+  }
+
+  const bot = botsJson.data.find(
+    (b) =>
+      b.name.toLowerCase() ===
+      name.toLowerCase()
+  );
+
+  if (!bot) {
+    console.log(
+      chalk.gray("(") +
+      chalk.red("!") +
+      chalk.gray(") ") +
+      chalk.red(`Bot "${name}" not found.`)
+    );
+
+    process.exit(1);
+  }
+
+  const response = await fetch(
+    "https://api.phanomcloud.online/bots/stop",
+    {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        bot_id: bot.id
+      })
+    }
+  );
+
+  const json = await response.json();
+
+  if (!json.success) {
+    console.log(
+      chalk.gray("(") +
+      chalk.red("!") +
+      chalk.gray(") ") +
+      chalk.red(
+        json.error ||
+        "Failed to stop bot."
+      )
+    );
+
+    process.exit(1);
+  }
+
+  console.log(
+    chalk.gray("(") +
+    chalk.red("*") +
+    chalk.gray(") Stopped ") +
+    chalk.red(bot.name) +
+    chalk.gray("...")
+  );
+}

package/src/commands/up.js

@@ -0,0 +1,213 @@
+import fs from "fs";
+import path from "path";
+
+import chalk from "chalk";
+import AdmZip from "adm-zip";
+
+import { getApiKey } from "../utils/config.js";
+
+function parseConfig(content) {
+  const lines = content.split("\n");
+
+  const data = {};
+
+  for (const line of lines) {
+    const parts = line.split("=");
+
+    const key = parts.shift()?.trim();
+    const value = parts.join("=")?.trim();
+
+    if (!key || !value) continue;
+
+    data[key] = value;
+  }
+
+  return data;
+}
+
+export default async function up(filePath) {
+  const apiKey = getApiKey();
+
+  if (!fs.existsSync(filePath)) {
+    console.log(
+      chalk.gray("(") +
+      chalk.red("!") +
+      chalk.gray(") ") +
+      chalk.red("File not found.")
+    );
+
+    process.exit(1);
+  }
+
+  const ext = path.extname(filePath);
+
+  if (
+    ext !== ".zip" &&
+    ext !== ".rar"
+  ) {
+    console.log(
+      chalk.gray("(") +
+      chalk.red("!") +
+      chalk.gray(") ") +
+      chalk.red(
+        "Only .zip and .rar are allowed."
+      )
+    );
+
+    process.exit(1);
+  }
+
+  const zip = new AdmZip(filePath);
+
+  const configEntry =
+    zip.getEntry(
+      "phanom-compose.config"
+    );
+
+  if (!configEntry) {
+    console.log(
+      chalk.gray("(") +
+      chalk.red("!") +
+      chalk.gray(") ") +
+      chalk.red(
+        "Missing phanom-compose.config"
+      )
+    );
+
+    process.exit(1);
+  }
+
+  const configContent =
+    zip
+      .readAsText(configEntry)
+      .toString();
+
+  const config =
+    parseConfig(configContent);
+
+  if (
+    !config.NAME ||
+    !config.STARTUP ||
+    !config.RAM ||
+    !config.RUNTIME
+  ) {
+    console.log(
+      chalk.gray("(") +
+      chalk.red("!") +
+      chalk.gray(") ") +
+      chalk.red(
+        "Invalid phanom-compose.config"
+      )
+    );
+
+    process.exit(1);
+  }
+
+  console.log(
+    chalk.gray("(") +
+    chalk.cyan("*") +
+    chalk.gray(") Creating ") +
+    chalk.cyan(config.NAME) +
+    chalk.gray("...")
+  );
+
+  const createResponse =
+    await fetch(
+      "https://api.phanomcloud.online/bots/create",
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          "Content-Type":
+            "application/json"
+        },
+        body: JSON.stringify({
+          name: config.NAME,
+          language: config.RUNTIME,
+          memory: Number(config.RAM),
+          startup_command:
+            config.STARTUP
+        })
+      }
+    );
+
+  const createJson =
+    await createResponse.json();
+
+  if (!createJson.success) {
+    console.log(
+      chalk.gray("(") +
+      chalk.red("!") +
+      chalk.gray(") ") +
+      chalk.red(
+        createJson.error ||
+        "Failed to create bot."
+      )
+    );
+
+    process.exit(1);
+  }
+
+  const botId =
+    createJson.data.id;
+
+  console.log(
+    chalk.gray("(") +
+    chalk.cyan("*") +
+    chalk.gray(") Uploading files...")
+  );
+
+  const fileBuffer =
+    await fs.promises.readFile(
+      filePath
+    );
+
+  const blob = new Blob([
+    fileBuffer
+  ]);
+
+  const form = new FormData();
+
+  form.append(
+    "file",
+    blob,
+    path.basename(filePath)
+  );
+
+  const uploadResponse =
+    await fetch(
+      `https://api.phanomcloud.online/bots/${botId}/upload`,
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${apiKey}`
+        },
+        body: form
+      }
+    );
+
+  const uploadJson =
+    await uploadResponse.json();
+
+  if (!uploadJson.success) {
+    console.log(
+      chalk.gray("(") +
+      chalk.red("!") +
+      chalk.gray(") ") +
+      chalk.red(
+        uploadJson.error ||
+        "Upload failed."
+      )
+    );
+
+    process.exit(1);
+  }
+
+  console.log(
+    chalk.gray("(") +
+    chalk.green("*") +
+    chalk.gray(") Uploaded ") +
+    chalk.green(config.NAME) +
+    chalk.gray(".")
+  );
+}

package/src/commands/upmemory.js

@@ -0,0 +1,115 @@
+import chalk from "chalk";
+import inquirer from "inquirer";
+
+import { getApiKey } from "../utils/config.js";
+
+export default async function upmemory(
+  name
+) {
+  const apiKey = getApiKey();
+
+  const botsResponse = await fetch(
+    "https://api.phanomcloud.online/bots",
+    {
+      headers: {
+        Authorization: `Bearer ${apiKey}`
+      }
+    }
+  );
+
+  if (!botsResponse.ok) {
+    process.exit(1);
+  }
+
+  const botsJson = await botsResponse.json();
+
+  if (!botsJson.success) {
+    process.exit(1);
+  }
+
+  const bot = botsJson.data.find(
+    (b) =>
+      b.name.toLowerCase() ===
+      name.toLowerCase()
+  );
+
+  if (!bot) {
+    console.log(
+      chalk.gray("(") +
+      chalk.red("!") +
+      chalk.gray(") ") +
+      chalk.red(`Bot "${name}" not found.`)
+    );
+
+    process.exit(1);
+  }
+
+  const answers = await inquirer.prompt([
+    {
+      type: "input",
+      name: "memory",
+      message:
+        chalk.gray("(") +
+        chalk.cyan("?") +
+        chalk.gray(") ") +
+        chalk.gray("Memory (MB): "),
+      validate(value) {
+        const num = Number(value);
+
+        if (isNaN(num)) {
+          return "Invalid number.";
+        }
+
+        if (num < 64) {
+          return "Minimum memory is 64MB.";
+        }
+
+        return true;
+      }
+    }
+  ]);
+
+  const response = await fetch(
+    `https://api.phanomcloud.online/bots/${bot.id}/memory`,
+    {
+      method: "PATCH",
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        memory: Number(
+          answers.memory
+        )
+      })
+    }
+  );
+
+  const json = await response.json();
+
+  if (!json.success) {
+    console.log(
+      chalk.gray("(") +
+      chalk.red("!") +
+      chalk.gray(") ") +
+      chalk.red(
+        json.error ||
+        "Failed to update memory."
+      )
+    );
+
+    process.exit(1);
+  }
+
+  console.log(
+    chalk.gray("(") +
+    chalk.green("*") +
+    chalk.gray(") Updated ") +
+    chalk.green(bot.name) +
+    chalk.gray(" to ") +
+    chalk.green(
+      `${json.data.memory}MB`
+    ) +
+    chalk.gray(".")
+  );
+}

package/src/index.js

@@ -0,0 +1,73 @@
+import { Command } from "commander";
+
+import init from "./commands/init.js";
+import ps from "./commands/ps.js";
+import logs from "./commands/logs.js";
+import start from "./commands/start.js";
+import stop from "./commands/stop.js";
+import restart from "./commands/restart.js";
+import upmemory from "./commands/upmemory.js";
+import up from "./commands/up.js";
+import shell from "./commands/shell.js";
+
+const program = new Command();
+
+program
+  .name("phanom")
+  .description("PhanomCloud CLI")
+  .version("0.0.1-beta");
+
+program
+  .command("init")
+  .description("Create or update your connection")
+  .action(init);
+
+program
+  .command("ps")
+  .description("List your bots")
+  .option("--a-z", "Sort from A to Z")
+  .option("--z-a", "Sort from Z to A")
+  .action((opts) =>
+    ps({
+      aZ: opts["a-z"],
+      zA: opts["z-a"]
+    })
+  );
+
+program
+  .command("logs <name>")
+  .description("Get bot logs")
+  .option("--lines <number>")
+  .action(logs);
+
+program
+  .command("start <name>")
+  .description("Start a bot")
+  .action(start);
+
+program
+  .command("stop <name>")
+  .description("Stop a bot")
+  .action(stop);
+
+program
+  .command("restart <name>")
+  .description("Restart a bot")
+  .action(restart);
+
+program
+  .command("upmemory <name>")
+  .description("Update bot memory")
+  .action(upmemory);
+
+program
+  .command("up <file>")
+  .description("Upload a PhanomCompose package")
+  .action(up);
+
+program
+  .command("shell <target>")
+  .description("Execute commands inside a bot")
+  .action(shell);
+
+program.parse(process.argv);

package/src/utils/config.js

@@ -0,0 +1,29 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+
+export function getApiKey() {
+  const rcPath = path.join(
+    os.homedir(),
+    ".openphanomid.rc"
+  );
+
+  if (!fs.existsSync(rcPath)) {
+    console.log("Missing API key.");
+    process.exit(1);
+  }
+
+  const content = fs.readFileSync(
+    rcPath,
+    "utf8"
+  );
+
+  const match = content.match(/API=(.+)/);
+
+  if (!match) {
+    console.log("Invalid config.");
+    process.exit(1);
+  }
+
+  return match[1].trim();
+}