@medialit/cli 0.0.0-stage → 0.1.0

package/README.md

@@ -1,3 +1,53 @@
-# Temporary Holding Version
+# @medialit/cli
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Upload and manage [MediaLit](https://medialit.cloud) files from the terminal.
+
+```bash
+npm install -g @medialit/cli
+medialit login
+medialit upload photo.jpg --public
+```
+
+## Log in
+
+```bash
+medialit login
+```
+
+Your browser opens to sign in. If you have more than one app, you choose the app the CLI works with. Run `medialit login` again to choose a different one.
+
+For a self-hosted MediaLit, pass its URL once. Later commands use the server you last logged in to:
+
+```bash
+medialit login --endpoint https://medialit.example.com
+```
+
+Without a browser, for example over SSH, use `--no-browser` and open the printed URL on another device whose browser can reach this machine's `127.0.0.1`.
+
+In CI, skip logging in and set `MEDIALIT_API_KEY` (and `MEDIALIT_ENDPOINT` if you self-host).
+
+## Commands
+
+| Command                    | What it does                                       |
+| -------------------------- | -------------------------------------------------- |
+| `medialit upload <files…>` | Uploads and seals files, then prints their URLs    |
+| `medialit ls`              | Lists sealed files, newest first                   |
+| `medialit get <id>`        | Prints a file's URL, a fresh one for private files |
+| `medialit seal <id>`       | Keeps a temporary upload                           |
+| `medialit rm <id>`         | Deletes a file                                     |
+| `medialit whoami`          | Shows the server, account, app and storage used    |
+| `medialit logout`          | Logs out of the server                             |
+
+Uploads are private unless you pass `--public`. Add `--caption <text>` or `--group <name>` to label them, or `--temp` to leave them unsealed so MediaLit deletes them after 24 hours. Large files are uploaded in chunks and retried if the connection drops.
+
+`ls` takes `--public`, `--private`, `--group <name>`, `--page <n>` and `--limit <n>`.
+
+Every command takes `--json`. URLs and JSON go to stdout and messages to stderr, so you can pipe the output:
+
+```bash
+medialit upload report.pdf --public | pbcopy
+```
+
+## Where your login is stored
+
+In `~/.config/medialit/credentials.json` (`%APPDATA%\medialit` on Windows), readable only by you. Set `MEDIALIT_CONFIG_DIR` to use another folder.

package/dist/index.mjs

@@ -0,0 +1,617 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { parseArgs } from "node:util";
+import { createRequire } from "node:module";
+
+// src/commands.ts
+import { spawn } from "node:child_process";
+import { createReadStream } from "node:fs";
+import { stat } from "node:fs/promises";
+import { basename } from "node:path";
+import { lookup } from "mime-types";
+import { uploadFile } from "@medialit/uploader";
+
+// src/credentials.ts
+import { chmod, mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+var DEFAULT_ENDPOINT = "https://api.medialit.cloud";
+function normalizeEndpoint(endpoint) {
+  return new URL(endpoint).toString().replace(/\/+$/, "");
+}
+function configDir() {
+  if (process.env.MEDIALIT_CONFIG_DIR) return process.env.MEDIALIT_CONFIG_DIR;
+  if (process.platform === "win32") {
+    return join(
+      process.env.APPDATA || join(homedir(), "AppData", "Roaming"),
+      "medialit"
+    );
+  }
+  return join(
+    process.env.XDG_CONFIG_HOME || join(homedir(), ".config"),
+    "medialit"
+  );
+}
+var credentialsFile = () => join(configDir(), "credentials.json");
+async function loadCredentials() {
+  try {
+    const parsed = JSON.parse(await readFile(credentialsFile(), "utf8"));
+    return { servers: {}, ...parsed };
+  } catch {
+    return { servers: {} };
+  }
+}
+async function saveCredentials(credentials) {
+  await mkdir(configDir(), { recursive: true, mode: 448 });
+  await writeFile(credentialsFile(), JSON.stringify(credentials, null, 2), {
+    mode: 384
+  });
+  await chmod(credentialsFile(), 384);
+}
+
+// src/oauth.ts
+import { createHash, randomBytes } from "node:crypto";
+import http from "node:http";
+var SCOPES = "openid email offline_access data:read data:write";
+var CALLBACK_PATH = "/callback";
+var LOGIN_TIMEOUT_MS = 5 * 60 * 1e3;
+async function discover(endpoint) {
+  const resource = await getJson(
+    `${endpoint}/.well-known/oauth-protected-resource`
+  );
+  const issuer = resource.authorization_servers?.[0];
+  if (!issuer) {
+    throw new Error(`${endpoint} does not support logging in with OAuth`);
+  }
+  const issuerUrl = new URL(issuer);
+  const path = issuerUrl.pathname === "/" ? "" : issuerUrl.pathname;
+  const server = await getJson(
+    `${issuerUrl.origin}/.well-known/oauth-authorization-server${path}`
+  );
+  return {
+    authorizationEndpoint: server.authorization_endpoint,
+    tokenEndpoint: server.token_endpoint,
+    registrationEndpoint: server.registration_endpoint,
+    revocationEndpoint: server.revocation_endpoint,
+    userinfoEndpoint: server.userinfo_endpoint,
+    resource: resource.resource
+  };
+}
+async function register(metadata) {
+  if (!metadata.registrationEndpoint) {
+    throw new Error("This server does not let the CLI register itself");
+  }
+  const response = await fetch(metadata.registrationEndpoint, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({
+      client_name: "MediaLit CLI",
+      application_type: "native",
+      // The server accepts any port on a loopback redirect (RFC 8252).
+      redirect_uris: [`http://127.0.0.1${CALLBACK_PATH}`],
+      grant_types: ["authorization_code", "refresh_token"],
+      response_types: ["code"],
+      token_endpoint_auth_method: "none",
+      scope: SCOPES
+    })
+  });
+  const body = await readJson(response);
+  if (!response.ok || !body.client_id) {
+    throw new Error(
+      `Could not register the CLI: ${errorMessage(body, response)}`
+    );
+  }
+  return body.client_id;
+}
+async function authorize(metadata, clientId, openUrl) {
+  const verifier = base64url(randomBytes(32));
+  const challenge = base64url(createHash("sha256").update(verifier).digest());
+  const state = base64url(randomBytes(16));
+  const callback = await listenForCallback(state);
+  const redirectUri = `http://127.0.0.1:${callback.port}${CALLBACK_PATH}`;
+  const url = new URL(metadata.authorizationEndpoint);
+  url.search = new URLSearchParams({
+    response_type: "code",
+    client_id: clientId,
+    redirect_uri: redirectUri,
+    scope: SCOPES,
+    state,
+    code_challenge: challenge,
+    code_challenge_method: "S256",
+    resource: metadata.resource
+  }).toString();
+  openUrl(url.toString());
+  const code = await callback.code;
+  const tokens = await requestTokens(metadata.tokenEndpoint, {
+    grant_type: "authorization_code",
+    code,
+    redirect_uri: redirectUri,
+    client_id: clientId,
+    code_verifier: verifier,
+    resource: metadata.resource
+  });
+  if (!tokens.email && metadata.userinfoEndpoint) {
+    tokens.email = await fetchEmail(
+      metadata.userinfoEndpoint,
+      tokens.accessToken
+    );
+  }
+  return tokens;
+}
+async function fetchEmail(userinfoEndpoint, accessToken) {
+  try {
+    const response = await fetch(userinfoEndpoint, {
+      headers: { authorization: `Bearer ${accessToken}` }
+    });
+    const body = await readJson(response);
+    return typeof body.email === "string" ? body.email : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function refresh(tokenEndpoint, input) {
+  return requestTokens(tokenEndpoint, {
+    grant_type: "refresh_token",
+    refresh_token: input.refreshToken,
+    client_id: input.clientId,
+    resource: input.resource
+  });
+}
+async function revoke(revocationEndpoint, input) {
+  await fetch(revocationEndpoint, {
+    method: "POST",
+    headers: { "content-type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      token: input.token,
+      token_type_hint: "refresh_token",
+      client_id: input.clientId
+    })
+  });
+}
+async function listenForCallback(state) {
+  let settle;
+  const code = new Promise((resolve, reject) => {
+    settle = { resolve, reject };
+  });
+  const server = http.createServer((req, res) => {
+    const url = new URL(req.url || "/", "http://127.0.0.1");
+    if (url.pathname !== CALLBACK_PATH) {
+      res.writeHead(404).end();
+      return;
+    }
+    const error = url.searchParams.get("error");
+    const received = url.searchParams.get("code");
+    if (error || !received || url.searchParams.get("state") !== state) {
+      respond(res, 400, "Login failed. Return to your terminal.");
+      settle.reject(
+        new Error(
+          url.searchParams.get("error_description") || error || "The login response was not valid"
+        )
+      );
+      return;
+    }
+    respond(res, 200, "You're logged in. You can close this tab.");
+    settle.resolve(received);
+  });
+  await new Promise(
+    (resolve) => server.listen(0, "127.0.0.1", resolve)
+  );
+  const timeout = setTimeout(
+    () => settle.reject(new Error("Timed out waiting for the login")),
+    LOGIN_TIMEOUT_MS
+  );
+  code.finally(() => {
+    clearTimeout(timeout);
+    server.close();
+  }).catch(() => void 0);
+  return { port: server.address().port, code };
+}
+function respond(res, status, message) {
+  res.writeHead(status, { "content-type": "text/html; charset=utf-8" });
+  res.end(
+    `<!doctype html><title>MediaLit CLI</title><body style="font-family:system-ui;display:grid;place-items:center;height:90vh"><p>${message}</p></body>`
+  );
+}
+async function requestTokens(tokenEndpoint, params) {
+  const response = await fetch(tokenEndpoint, {
+    method: "POST",
+    headers: { "content-type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams(params)
+  });
+  const body = await readJson(response);
+  if (!response.ok || !body.access_token) {
+    throw new Error(errorMessage(body, response));
+  }
+  return {
+    accessToken: body.access_token,
+    refreshToken: body.refresh_token,
+    expiresAt: body.expires_in ? Date.now() + body.expires_in * 1e3 : void 0,
+    email: jwtClaim(body.id_token, "email"),
+    appId: jwtClaim(body.access_token, "app_id")
+  };
+}
+function jwtClaim(token, name) {
+  if (typeof token !== "string") return void 0;
+  const payload = token.split(".")[1];
+  if (!payload) return void 0;
+  try {
+    const value = JSON.parse(Buffer.from(payload, "base64url").toString())[name];
+    return typeof value === "string" ? value : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function getJson(url) {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`${url} responded with ${response.status}`);
+  }
+  return response.json();
+}
+async function readJson(response) {
+  return response.json().catch(() => ({}));
+}
+function errorMessage(body, response) {
+  return body?.error_description || body?.error || `the server responded with ${response.status}`;
+}
+function base64url(bytes) {
+  return bytes.toString("base64url");
+}
+
+// src/session.ts
+import { MediaLit } from "medialit";
+var REFRESH_MARGIN_MS = 60 * 1e3;
+async function resolveEndpoint(flag) {
+  if (flag) return normalizeEndpoint(flag);
+  if (process.env.MEDIALIT_ENDPOINT) {
+    return normalizeEndpoint(process.env.MEDIALIT_ENDPOINT);
+  }
+  return (await loadCredentials()).current || DEFAULT_ENDPOINT;
+}
+async function getClient(endpointFlag) {
+  const endpoint = await resolveEndpoint(endpointFlag);
+  if (process.env.MEDIALIT_API_KEY) {
+    return {
+      client: new MediaLit({
+        apiKey: process.env.MEDIALIT_API_KEY,
+        endpoint
+      }),
+      endpoint
+    };
+  }
+  const credentials = await loadCredentials();
+  const server = credentials.servers[endpoint];
+  if (!server?.accessToken) {
+    throw new Error(
+      `Not logged in to ${endpoint}. Run \`medialit login\` first.`
+    );
+  }
+  if (server.expiresAt && server.expiresAt - Date.now() < REFRESH_MARGIN_MS) {
+    if (!server.refreshToken) {
+      throw new Error(
+        "Your login has expired. Run `medialit login` again."
+      );
+    }
+    let tokens;
+    try {
+      tokens = await refresh(server.tokenEndpoint, {
+        clientId: server.clientId,
+        refreshToken: server.refreshToken,
+        resource: server.resource
+      });
+    } catch {
+      throw new Error(
+        "Your login has expired. Run `medialit login` again."
+      );
+    }
+    server.accessToken = tokens.accessToken;
+    server.refreshToken = tokens.refreshToken || server.refreshToken;
+    server.expiresAt = tokens.expiresAt;
+    server.appId = tokens.appId || server.appId;
+    await saveCredentials(credentials);
+  }
+  return {
+    client: new MediaLit({ accessToken: server.accessToken, endpoint }),
+    endpoint
+  };
+}
+
+// src/commands.ts
+async function login(flags) {
+  const endpoint = await resolveEndpoint(flags.endpoint);
+  const metadata = await discover(endpoint);
+  const credentials = await loadCredentials();
+  const previous = credentials.servers[endpoint];
+  const clientId = previous?.clientId || await register(metadata);
+  const tokens = await authorize(metadata, clientId, (url) => {
+    log(`Opening your browser to log in to ${endpoint}.`);
+    log(`If it doesn't open, visit:
+
+  ${url}
+`);
+    if (flags.browser !== false) openBrowser(url);
+  });
+  credentials.servers[endpoint] = {
+    clientId,
+    tokenEndpoint: metadata.tokenEndpoint,
+    revocationEndpoint: metadata.revocationEndpoint,
+    resource: metadata.resource,
+    ...tokens
+  };
+  credentials.current = endpoint;
+  await saveCredentials(credentials);
+  output(
+    flags,
+    { endpoint, email: tokens.email, appId: tokens.appId },
+    () => [
+      `Logged in${tokens.email ? ` as ${tokens.email}` : ""}.`,
+      tokens.appId ? `Uploads go to app ${tokens.appId}.` : "",
+      "Run `medialit login` again to choose a different app."
+    ].filter(Boolean).join("\n")
+  );
+}
+async function logout(flags) {
+  const endpoint = await resolveEndpoint(flags.endpoint);
+  const credentials = await loadCredentials();
+  const server = credentials.servers[endpoint];
+  if (server?.refreshToken && server.revocationEndpoint) {
+    await revoke(server.revocationEndpoint, {
+      clientId: server.clientId,
+      token: server.refreshToken
+    }).catch(() => void 0);
+  }
+  if (server) {
+    credentials.servers[endpoint] = {
+      clientId: server.clientId,
+      tokenEndpoint: server.tokenEndpoint,
+      revocationEndpoint: server.revocationEndpoint,
+      resource: server.resource
+    };
+    await saveCredentials(credentials);
+  }
+  output(flags, { endpoint }, () => `Logged out of ${endpoint}.`);
+}
+async function whoami(flags) {
+  const { client, endpoint } = await getClient(flags.endpoint);
+  const server = (await loadCredentials()).servers[endpoint];
+  const usingApiKey = !!process.env.MEDIALIT_API_KEY;
+  const [stats, count] = await Promise.all([
+    client.getStats(),
+    client.getCount()
+  ]);
+  const info = {
+    endpoint,
+    auth: usingApiKey ? "api-key" : "login",
+    email: usingApiKey ? void 0 : server?.email,
+    appId: usingApiKey ? void 0 : server?.appId,
+    files: count,
+    storage: stats.storage,
+    maxStorage: stats.maxStorage
+  };
+  output(
+    flags,
+    info,
+    () => [
+      `Server:  ${endpoint}`,
+      usingApiKey ? "Using:   MEDIALIT_API_KEY" : `Account: ${info.email || "unknown"}`,
+      info.appId ? `App:     ${info.appId}` : "",
+      `Files:   ${count}`,
+      `Storage: ${formatBytes(stats.storage)} of ${formatBytes(stats.maxStorage)}`
+    ].filter(Boolean).join("\n")
+  );
+}
+async function upload(paths, flags) {
+  if (!paths.length) throw new Error("Pass at least one file to upload.");
+  const { client, endpoint } = await getClient(flags.endpoint);
+  const results = [];
+  for (const path of paths) {
+    const info = await stat(path).catch(() => null);
+    if (!info?.isFile()) throw new Error(`${path} is not a file`);
+    const fileName = basename(path);
+    const media = await uploadFile(createReadStream(path), {
+      getSignature: async () => ({
+        signature: await client.getSignature({ group: flags.group }),
+        endpoint
+      }),
+      fileName,
+      mimeType: lookup(fileName) || void 0,
+      access: flags.public ? "public" : "private",
+      caption: flags.caption,
+      // Chunks let a dropped connection resume instead of restarting.
+      chunkSize: 8 * 1024 * 1024,
+      onProgress: ({ percentage }) => progress(`${fileName}  ${Math.floor(percentage)}%`)
+    });
+    progress("");
+    const kept = flags.temp ? media : await client.seal(media.mediaId);
+    results.push(kept);
+    if (!flags.json) {
+      log(`${kept.originalFileName}  ${kept.mediaId}`);
+      console.log(kept.file);
+    }
+  }
+  if (flags.json) console.log(JSON.stringify(results, null, 2));
+  else if (flags.temp) {
+    log(
+      "\nThese uploads are temporary. Seal them with `medialit seal <id>` or they are deleted after 24 hours."
+    );
+  }
+}
+async function list(flags) {
+  const { client } = await getClient(flags.endpoint);
+  const access = flags.public ? "public" : flags.private ? "private" : void 0;
+  const media = await client.list(
+    Number(flags.page || 1),
+    Number(flags.limit || 20),
+    { access, group: flags.group }
+  );
+  output(
+    flags,
+    media,
+    () => media.length ? table(
+      media.map((m) => [
+        m.mediaId,
+        m.access,
+        formatBytes(m.size),
+        m.originalFileName
+      ])
+    ) : "No files."
+  );
+}
+async function get(ids, flags) {
+  const { client } = await getClient(flags.endpoint);
+  const media = await client.get(
+    requireId(ids)
+  );
+  output(flags, media, () => media.file);
+}
+async function seal(ids, flags) {
+  const { client } = await getClient(flags.endpoint);
+  const media = await client.seal(
+    requireId(ids)
+  );
+  output(flags, media, () => media.file);
+}
+async function remove(ids, flags) {
+  const { client } = await getClient(flags.endpoint);
+  const id = requireId(ids);
+  await client.delete(id);
+  output(flags, { deleted: true, mediaId: id }, () => `Deleted ${id}.`);
+}
+function requireId(ids) {
+  if (ids.length !== 1) throw new Error("Pass one media ID.");
+  return ids[0];
+}
+function output(flags, data, human) {
+  console.log(flags.json ? JSON.stringify(data, null, 2) : human());
+}
+function log(message) {
+  console.error(message);
+}
+function progress(message) {
+  if (!process.stderr.isTTY) return;
+  process.stderr.write(`\r\x1B[2K${message}`);
+}
+function table(rows) {
+  const widths = rows[0].map(
+    (_, i) => Math.max(...rows.map((row) => row[i].length))
+  );
+  return rows.map(
+    (row) => row.map(
+      (cell, i) => i === row.length - 1 ? cell : cell.padEnd(widths[i])
+    ).join("  ")
+  ).join("\n");
+}
+function formatBytes(bytes) {
+  const units = ["B", "KB", "MB", "GB", "TB"];
+  let value = bytes;
+  let unit = 0;
+  while (value >= 1024 && unit < units.length - 1) {
+    value /= 1024;
+    unit++;
+  }
+  const rounded = value >= 10 || unit === 0 ? Math.round(value) : value.toFixed(1);
+  return `${rounded} ${units[unit]}`;
+}
+function openBrowser(url) {
+  const [command, args] = process.platform === "darwin" ? ["open", [url]] : process.platform === "win32" ? ["rundll32", ["url.dll,FileProtocolHandler", url]] : ["xdg-open", [url]];
+  try {
+    spawn(command, args, { stdio: "ignore", detached: true }).on("error", () => void 0).unref();
+  } catch {
+  }
+}
+
+// src/index.ts
+var HELP = `Usage: medialit <command> [options]
+
+Commands:
+  login                 Log in with your browser and choose an app
+  logout                Log out of the server
+  whoami                Show the server, account, app and storage used
+  upload <files...>     Upload and seal files, then print their URLs
+  ls                    List sealed files, newest first
+  get <id>              Print a file's URL (a fresh one for private files)
+  seal <id>             Keep a temporary upload
+  rm <id>               Delete a file
+
+Options:
+  --endpoint <url>      MediaLit server, for self-hosted instances
+                        (default: the server you last logged in to,
+                        or https://api.medialit.cloud)
+  --json                Print JSON
+  --public              upload: make files public. ls: only public files
+  --private             ls: only private files
+  --caption <text>      upload: caption for the files
+  --group <name>        upload: put files in a group. ls: only that group
+  --temp                upload: don't seal, so unused files are deleted
+  --page <n>, --limit <n>   ls: page through files
+  --no-browser          login: print the URL instead of opening it
+  -h, --help            Show this help
+  -v, --version         Show the version
+
+Environment:
+  MEDIALIT_API_KEY      Use an API key instead of logging in, for CI
+  MEDIALIT_ENDPOINT     Same as --endpoint
+`;
+async function main(argv) {
+  const { values, positionals } = parseArgs({
+    args: argv,
+    allowPositionals: true,
+    options: {
+      endpoint: { type: "string" },
+      json: { type: "boolean" },
+      public: { type: "boolean" },
+      private: { type: "boolean" },
+      caption: { type: "string" },
+      group: { type: "string" },
+      temp: { type: "boolean" },
+      page: { type: "string" },
+      limit: { type: "string" },
+      "no-browser": { type: "boolean" },
+      help: { type: "boolean", short: "h" },
+      version: { type: "boolean", short: "v" }
+    }
+  });
+  const flags = {
+    ...values,
+    browser: !values["no-browser"]
+  };
+  const [command, ...args] = positionals;
+  if (values.version) {
+    const require2 = createRequire(import.meta.url);
+    console.log(require2("../package.json").version);
+    return;
+  }
+  if (values.help || !command) {
+    console.log(HELP);
+    return;
+  }
+  switch (command) {
+    case "login":
+      return login(flags);
+    case "logout":
+      return logout(flags);
+    case "whoami":
+      return whoami(flags);
+    case "upload":
+      return upload(args, flags);
+    case "ls":
+    case "list":
+      return list(flags);
+    case "get":
+      return get(args, flags);
+    case "seal":
+      return seal(args, flags);
+    case "rm":
+    case "delete":
+      return remove(args, flags);
+    default:
+      throw new Error(
+        `Unknown command "${command}". Run \`medialit --help\`.`
+      );
+  }
+}
+main(process.argv.slice(2)).catch((err) => {
+  console.error(`error: ${err.message}`);
+  process.exitCode = 1;
+});

package/package.json

@@ -1,6 +1,47 @@
 {
   "name": "@medialit/cli",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Upload and manage MediaLit files from the terminal",
+  "type": "module",
+  "bin": {
+    "medialit": "dist/index.mjs"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "test": "bun --filter medialit --filter @medialit/uploader build && node --import tsx --test '__tests__/**/*.test.ts'",
+    "prepublishOnly": "bun run build"
+  },
+  "keywords": [
+    "medialit",
+    "cli",
+    "upload",
+    "storage"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/codelitdev/medialit"
+  },
+  "dependencies": {
+    "@medialit/uploader": "^0.1.0",
+    "medialit": "^0.2.0",
+    "mime-types": "^3.0.2"
+  },
+  "devDependencies": {
+    "@types/mime-types": "^3.0.1",
+    "@types/node": "^20.0.0",
+    "tsup": "^8.0.0",
+    "tsx": "^4.19.3",
+    "typescript": "^5.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "packageManager": "bun@1.4.1"
+}