@sandboxsonny/ace-kit 0.5.0 → 0.6.0

package/dist/environment-T5K5ZJ2M.js

@@ -0,0 +1,222 @@
+#!/usr/bin/env node
+import {
+  normaliseApiUrl,
+  parseStoredLogin
+} from "./chunk-7M26C36M.js";
+
+// src/cli/environment.ts
+import { spawn } from "child_process";
+import { hostname } from "os";
+import { fileURLToPath, pathToFileURL } from "url";
+
+// src/auth/file-store.ts
+import { mkdir, readFile, rename, writeFile } from "fs/promises";
+import { homedir } from "os";
+import { dirname, join } from "path";
+function defaultLoginFile(variables, platform) {
+  if (platform === "win32" && variables.APPDATA) return join(variables.APPDATA, "ace-kit", "credentials.json");
+  const configFolder = variables.XDG_CONFIG_HOME || join(homedir(), ".config");
+  return join(configFolder, "ace-kit", "credentials.json");
+}
+function createFileStore(path) {
+  async function readAll() {
+    let text;
+    try {
+      text = await readFile(path, "utf8");
+    } catch {
+      return {};
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(text);
+    } catch {
+      return {};
+    }
+    const found = {};
+    if (typeof parsed === "object" && parsed !== null) {
+      for (const [address, value] of Object.entries(parsed)) {
+        const login = parseStoredLogin(value);
+        if (login) found[address] = login;
+      }
+    }
+    return found;
+  }
+  async function writeAll(logins) {
+    await mkdir(dirname(path), { recursive: true, mode: 448 });
+    const temporary = `${path}.${process.pid}.tmp`;
+    await writeFile(temporary, `${JSON.stringify(logins, null, 2)}
+`, { mode: 384 });
+    await rename(temporary, path);
+  }
+  return {
+    description: path,
+    async read(apiUrl) {
+      return (await readAll())[normaliseApiUrl(apiUrl)] ?? null;
+    },
+    async write(apiUrl, login) {
+      const logins = await readAll();
+      logins[normaliseApiUrl(apiUrl)] = login;
+      await writeAll(logins);
+    },
+    async remove(apiUrl) {
+      const logins = await readAll();
+      delete logins[normaliseApiUrl(apiUrl)];
+      await writeAll(logins);
+    }
+  };
+}
+
+// src/auth/keychain-store.ts
+var keychainService = "ace-kit";
+function createKeychainStore(run) {
+  async function read(apiUrl) {
+    const found = await run("security", [
+      "find-generic-password",
+      "-s",
+      keychainService,
+      "-a",
+      normaliseApiUrl(apiUrl),
+      "-w"
+    ]);
+    if (found.exitCode !== 0) return null;
+    try {
+      return parseStoredLogin(JSON.parse(Buffer.from(found.stdout.trim(), "base64").toString("utf8")));
+    } catch {
+      return null;
+    }
+  }
+  return {
+    description: "the macOS Keychain",
+    read,
+    async write(apiUrl, login) {
+      const account = normaliseApiUrl(apiUrl);
+      if (/["\\\s]/.test(account)) throw new Error("That API address can't be kept in the Keychain.");
+      const secret = Buffer.from(JSON.stringify(login), "utf8").toString("base64");
+      await run(
+        "security",
+        ["-i"],
+        `add-generic-password -s "${keychainService}" -a "${account}" -l "Ace Kit login" -w "${secret}" -U
+`
+      );
+      const kept = await read(apiUrl);
+      if (kept?.token !== login.token) throw new Error("The login could not be saved in the macOS Keychain.");
+    },
+    async remove(apiUrl) {
+      await run("security", ["delete-generic-password", "-s", keychainService, "-a", normaliseApiUrl(apiUrl)]);
+    }
+  };
+}
+
+// src/auth/choose-store.ts
+async function chooseLoginStore(options) {
+  const file = createFileStore(defaultLoginFile(options.variables, options.platform));
+  if (options.platform !== "darwin" || options.variables.ACE_KIT_CREDENTIALS === "file") return file;
+  try {
+    await options.run("security", ["help"]);
+    return createKeychainStore(options.run);
+  } catch {
+    return file;
+  }
+}
+
+// src/auth/last-api-url.ts
+import { mkdir as mkdir2, readFile as readFile2, rename as rename2, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname2, join as join2 } from "path";
+function defaultLastApiUrlFile(variables, platform) {
+  return join2(dirname2(defaultLoginFile(variables, platform)), "last-api-url");
+}
+function createLastApiUrl(path) {
+  return {
+    async read() {
+      try {
+        return normaliseApiUrl((await readFile2(path, "utf8")).trim());
+      } catch {
+        return null;
+      }
+    },
+    async write(apiUrl) {
+      await mkdir2(dirname2(path), { recursive: true, mode: 448 });
+      const temporary = `${path}.${process.pid}.tmp`;
+      await writeFile2(temporary, `${normaliseApiUrl(apiUrl)}
+`, { mode: 384 });
+      await rename2(temporary, path);
+    }
+  };
+}
+
+// src/cli/version.ts
+var aceKitVersion = true ? "0.6.0" : "development";
+
+// src/cli/environment.ts
+var runCommand = (command, commandArguments, input) => new Promise((resolve, reject) => {
+  const child = spawn(command, commandArguments, { stdio: ["pipe", "pipe", "ignore"] });
+  let stdout = "";
+  child.stdout.on("data", (chunk) => {
+    stdout += chunk.toString("utf8");
+  });
+  child.on("error", reject);
+  child.on("close", (exitCode) => resolve({ exitCode: exitCode ?? 1, stdout }));
+  child.stdin.on("error", () => {
+  });
+  child.stdin.end(input ?? "");
+});
+function browserCommand(platform, address) {
+  if (platform === "darwin") return { command: "open", commandArguments: [address] };
+  if (platform === "win32") return { command: "rundll32", commandArguments: ["url.dll,FileProtocolHandler", address] };
+  return { command: "xdg-open", commandArguments: [address] };
+}
+async function openBrowser(platform, address) {
+  const { command, commandArguments } = browserCommand(platform, address);
+  await new Promise((resolve) => {
+    const child = spawn(command, commandArguments, { stdio: "ignore", detached: true });
+    child.on("error", () => resolve());
+    child.on("spawn", () => {
+      child.unref();
+      resolve();
+    });
+  });
+}
+async function importModule(path) {
+  try {
+    return await import(pathToFileURL(path).href);
+  } catch (error) {
+    if (error.code === "ERR_UNKNOWN_FILE_EXTENSION") {
+      throw new Error(
+        "this version of Node can't run TypeScript files. Use Node 22.18 or newer, or write the schema in .js.",
+        { cause: error }
+      );
+    }
+    throw error;
+  }
+}
+async function createRealEnvironment() {
+  try {
+    process.loadEnvFile(".env");
+  } catch {
+  }
+  const variables = { ...process.env };
+  const platform = process.platform;
+  return {
+    variables,
+    platform,
+    hostname: hostname(),
+    version: aceKitVersion,
+    out: (text) => process.stdout.write(`${text}
+`),
+    error: (text) => console.error(text),
+    fetchImplementation: (input, init) => fetch(input, init),
+    sleep: (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)),
+    now: Date.now,
+    workingDirectory: process.cwd(),
+    templatesDirectory: fileURLToPath(new URL("../templates", import.meta.url)),
+    importModule,
+    openBrowser: (address) => openBrowser(platform, address),
+    store: await chooseLoginStore({ platform, variables, run: runCommand }),
+    lastApiUrl: createLastApiUrl(defaultLastApiUrlFile(variables, platform))
+  };
+}
+export {
+  browserCommand,
+  createRealEnvironment,
+  runCommand
+};