disk 0.7.1 → 0.8.8

package/dist/index.cjs

@@ -0,0 +1,421 @@
+"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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Archil: () => Archil,
+  ArchilApiError: () => ArchilApiError,
+  Disk: () => Disk,
+  Disks: () => Disks,
+  Tokens: () => Tokens,
+  configure: () => configure,
+  createApiKey: () => createApiKey,
+  createDisk: () => createDisk,
+  deleteApiKey: () => deleteApiKey,
+  getDisk: () => getDisk,
+  listApiKeys: () => listApiKeys,
+  listDisks: () => listDisks
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/client.ts
+var import_openapi_fetch = __toESM(require("openapi-fetch"), 1);
+
+// src/errors.ts
+var ArchilApiError = class extends Error {
+  status;
+  code;
+  constructor(message, status, code) {
+    super(message);
+    this.name = "ArchilApiError";
+    this.status = status;
+    this.code = code;
+  }
+};
+
+// src/regions.ts
+var REGION_URLS = {
+  "aws-us-east-1": "https://control.green.us-east-1.aws.prod.archil.com",
+  "aws-us-west-2": "https://control.green.us-west-2.aws.prod.archil.com",
+  "aws-eu-west-1": "https://control.green.eu-west-1.aws.prod.archil.com",
+  "gcp-us-central1": "https://control.blue.us-central1.gcp.prod.archil.com"
+};
+function resolveBaseUrl(region) {
+  const url = REGION_URLS[region];
+  if (!url) {
+    throw new Error(
+      `Unknown region "${region}". Valid regions: ${Object.keys(REGION_URLS).join(", ")}`
+    );
+  }
+  return url;
+}
+
+// src/client.ts
+function createApiClient(opts) {
+  const baseUrl = opts.baseUrl ?? resolveBaseUrl(opts.region);
+  return (0, import_openapi_fetch.default)({
+    baseUrl,
+    headers: {
+      Authorization: `key-${opts.apiKey.replace(/^key-/, "")}`
+    }
+  });
+}
+async function unwrap(promise) {
+  const { data: body, error, response } = await promise;
+  if (error || !body) {
+    const errBody = error;
+    throw new ArchilApiError(
+      errBody?.error ?? `API request failed with status ${response.status}`,
+      response.status
+    );
+  }
+  if (!body.success) {
+    throw new ArchilApiError(
+      body.error ?? "Unknown API error",
+      response.status
+    );
+  }
+  return body.data;
+}
+async function unwrapEmpty(promise) {
+  const { data: body, error, response } = await promise;
+  if (error || !body) {
+    const errBody = error;
+    throw new ArchilApiError(
+      errBody?.error ?? `API request failed with status ${response.status}`,
+      response.status
+    );
+  }
+  if (!body.success) {
+    throw new ArchilApiError(
+      body.error ?? "Unknown API error",
+      response.status
+    );
+  }
+}
+
+// src/disk.ts
+var import_node_module = require("module");
+var import_node_url = require("url");
+var import_meta = {};
+var Disk = class {
+  id;
+  name;
+  organization;
+  status;
+  provider;
+  region;
+  createdAt;
+  fsHandlerStatus;
+  lastAccessed;
+  dataSize;
+  monthlyUsage;
+  mounts;
+  metrics;
+  connectedClients;
+  authorizedUsers;
+  /** @internal */
+  _client;
+  /** @internal */
+  _archilRegion;
+  /** @internal */
+  constructor(data, client, archilRegion) {
+    this.id = data.id;
+    this.name = data.name;
+    this.organization = data.organization;
+    this.status = data.status;
+    this.provider = data.provider;
+    this.region = data.region;
+    this.createdAt = data.createdAt;
+    this.fsHandlerStatus = data.fsHandlerStatus;
+    this.lastAccessed = data.lastAccessed;
+    this.dataSize = data.dataSize;
+    this.monthlyUsage = data.monthlyUsage;
+    this.mounts = data.mounts;
+    this.metrics = data.metrics;
+    this.connectedClients = data.connectedClients;
+    this.authorizedUsers = data.authorizedUsers;
+    this._client = client;
+    this._archilRegion = archilRegion;
+  }
+  toJSON() {
+    return {
+      id: this.id,
+      name: this.name,
+      organization: this.organization,
+      status: this.status,
+      provider: this.provider,
+      region: this.region,
+      createdAt: this.createdAt,
+      fsHandlerStatus: this.fsHandlerStatus,
+      lastAccessed: this.lastAccessed,
+      dataSize: this.dataSize,
+      monthlyUsage: this.monthlyUsage,
+      mounts: this.mounts,
+      metrics: this.metrics,
+      connectedClients: this.connectedClients,
+      authorizedUsers: this.authorizedUsers
+    };
+  }
+  async addUser(user) {
+    return unwrap(
+      this._client.POST("/api/disks/{id}/users", {
+        params: { path: { id: this.id } },
+        body: user
+      })
+    );
+  }
+  async removeUser(userType, identifier) {
+    await unwrapEmpty(
+      this._client.DELETE("/api/disks/{id}/users/{userType}", {
+        params: {
+          path: { id: this.id, userType },
+          query: { identifier }
+        }
+      })
+    );
+  }
+  async createToken(nickname) {
+    const user = await unwrap(
+      this._client.POST("/api/disks/{id}/users", {
+        params: { path: { id: this.id } },
+        body: { type: "token", nickname }
+      })
+    );
+    if (!user.token || !user.identifier) {
+      throw new Error("Server did not return a generated token");
+    }
+    return user;
+  }
+  async removeTokenUser(identifier) {
+    await this.removeUser("token", identifier);
+  }
+  async delete() {
+    await unwrapEmpty(
+      this._client.DELETE("/api/disks/{id}", {
+        params: { path: { id: this.id } }
+      })
+    );
+  }
+  /**
+   * Execute a command in a container with this disk mounted.
+   * Blocks until the command completes and returns stdout, stderr, and exit code.
+   */
+  async exec(command) {
+    return unwrap(
+      this._client.POST("/api/disks/{id}/exec", {
+        params: { path: { id: this.id } },
+        body: { command }
+      })
+    );
+  }
+  /**
+   * Connect to this disk's data plane via the native ArchilClient.
+   *
+   * Requires the native module to be available (platform-specific .node binary).
+   */
+  async mount(opts) {
+    let ArchilClient;
+    try {
+      const base = typeof import_meta !== "undefined" && import_meta.url ? import_meta.url : (0, import_node_url.pathToFileURL)(__filename).href;
+      const nativeRequire = (0, import_node_module.createRequire)(base);
+      const native = nativeRequire("@archildata/native");
+      ArchilClient = native.ArchilClient;
+    } catch {
+      throw new Error(
+        "Native client not available. Install @archildata/native (platform-specific binary) or use ArchilClient.connect() directly."
+      );
+    }
+    return ArchilClient.connect({
+      region: this._archilRegion,
+      diskName: `${this.organization}/${this.name}`,
+      authToken: opts?.authToken,
+      logLevel: opts?.logLevel,
+      serverAddress: opts?.serverAddress,
+      insecure: opts?.insecure
+    });
+  }
+};
+
+// src/disks.ts
+var Disks = class {
+  /** @internal */
+  _client;
+  /** @internal */
+  _region;
+  /** @internal */
+  constructor(client, region) {
+    this._client = client;
+    this._region = region;
+  }
+  async list(opts) {
+    const data = await unwrap(
+      this._client.GET("/api/disks", {
+        params: { query: { limit: opts?.limit, cursor: opts?.cursor } }
+      })
+    );
+    return data.map(
+      (d) => new Disk(d, this._client, this._region)
+    );
+  }
+  async get(id) {
+    const data = await unwrap(
+      this._client.GET("/api/disks/{id}", {
+        params: { path: { id } }
+      })
+    );
+    return new Disk(data, this._client, this._region);
+  }
+  /**
+   * Create a new disk with an auto-generated mount token.
+   *
+   * Returns the Disk, the one-time token (save it — it cannot be retrieved
+   * again), and the token identifier for later management.
+   */
+  async create(req) {
+    const created = await unwrap(
+      this._client.POST("/api/disks", { body: req })
+    );
+    const resp = created;
+    if (!resp.diskId) {
+      throw new Error("API returned success but no diskId");
+    }
+    const authorizedUsers = resp.authorizedUsers ?? [];
+    const tokenUser = authorizedUsers.find((u) => u.token);
+    const disk = await this.get(resp.diskId);
+    return {
+      disk,
+      token: tokenUser?.token ?? null,
+      tokenIdentifier: tokenUser?.identifier ?? null,
+      authorizedUsers
+    };
+  }
+};
+
+// src/tokens.ts
+var Tokens = class {
+  /** @internal */
+  _client;
+  /** @internal */
+  constructor(client) {
+    this._client = client;
+  }
+  async list(opts) {
+    const data = await unwrap(
+      this._client.GET("/api/tokens", {
+        params: { query: { limit: opts?.limit, cursor: opts?.cursor } }
+      })
+    );
+    return data.tokens ?? [];
+  }
+  async create(req) {
+    const data = await unwrap(
+      this._client.POST("/api/tokens", { body: req })
+    );
+    return data;
+  }
+  async delete(id) {
+    await unwrapEmpty(
+      this._client.DELETE("/api/tokens/{id}", {
+        params: { path: { id } }
+      })
+    );
+  }
+};
+
+// src/archil.ts
+var Archil = class {
+  disks;
+  tokens;
+  constructor(opts = {}) {
+    const apiKey = opts.apiKey ?? process.env.ARCHIL_API_KEY;
+    const region = opts.region ?? process.env.ARCHIL_REGION;
+    if (!apiKey) {
+      throw new Error("Missing API key: pass apiKey in options or set ARCHIL_API_KEY environment variable");
+    }
+    if (!region) {
+      throw new Error("Missing region: pass region in options or set ARCHIL_REGION environment variable");
+    }
+    const client = createApiClient({
+      apiKey,
+      region,
+      baseUrl: opts.baseUrl
+    });
+    this.disks = new Disks(client, region);
+    this.tokens = new Tokens(client);
+  }
+};
+
+// src/index.ts
+var _options;
+var _instance;
+function configure(options) {
+  _options = options;
+  _instance = void 0;
+}
+function archil() {
+  if (!_instance) {
+    _instance = new Archil(_options);
+  }
+  return _instance;
+}
+function createDisk(req) {
+  return archil().disks.create(req);
+}
+function listDisks(opts) {
+  return archil().disks.list(opts);
+}
+function getDisk(id) {
+  return archil().disks.get(id);
+}
+function listApiKeys(opts) {
+  return archil().tokens.list(opts);
+}
+function createApiKey(req) {
+  return archil().tokens.create(req);
+}
+function deleteApiKey(id) {
+  return archil().tokens.delete(id);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Archil,
+  ArchilApiError,
+  Disk,
+  Disks,
+  Tokens,
+  configure,
+  createApiKey,
+  createDisk,
+  deleteApiKey,
+  getDisk,
+  listApiKeys,
+  listDisks
+});