disk 0.7.1 → 0.8.8

package/dist/index.js

@@ -0,0 +1,372 @@
+// src/client.ts
+import createClient from "openapi-fetch";
+
+// 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 createClient({
+    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
+import { createRequire } from "module";
+import { pathToFileURL } from "url";
+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 : pathToFileURL(__filename).href;
+      const nativeRequire = 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);
+}
+export {
+  Archil,
+  ArchilApiError,
+  Disk,
+  Disks,
+  Tokens,
+  configure,
+  createApiKey,
+  createDisk,
+  deleteApiKey,
+  getDisk,
+  listApiKeys,
+  listDisks
+};

package/package.json

@@ -1,46 +1,50 @@
 {
   "name": "disk",
-  "version": "0.7.1",
-  "description": "Handle physical & virtual block devices",
-  "author": "Jonas Hermsmeier <jhermsmeier@gmail.com> (https://jhermsmeier.de)",
-  "license": "MIT",
-  "keywords": [
-    "disk",
-    "fs",
-    "mbr",
-    "gpt",
-    "partition",
-    "filesystem",
-    "file",
-    "system",
-    "blockdevice",
-    "master boot record",
-    "guid partition table",
-    "hdd"
-  ],
-  "main": "lib/disk",
-  "dependencies": {
-    "debug": "^3.1.0",
-    "gpt": "^1.0.0",
-    "mbr": "^1.1.2"
+  "version": "0.8.8",
+  "description": "Pure-JS client and CLI for Archil disks",
+  "type": "module",
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
   },
-  "devDependencies": {
-    "blockdevice": "^0.6.0",
-    "mocha": "^5.1.1",
-    "ramdisk": "^0.3.1"
+  "bin": {
+    "disk": "./dist/cli.js"
   },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
   "scripts": {
-    "test": "mocha"
+    "generate": "openapi-typescript ../../api/controlplane/openapi.yaml -o src/generated/openapi.d.ts",
+    "build": "npm run generate && tsup src/index.ts --format cjs,esm --dts && tsup bin/cli.ts --format esm --outDir dist --no-splitting",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "typecheck": "npm run generate && tsc --noEmit"
   },
-  "homepage": "https://github.com/jhermsmeier/node-disk",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/jhermsmeier/node-disk.git"
+  "dependencies": {
+    "commander": "^14.0.3",
+    "openapi-fetch": "^0.13.5"
+  },
+  "devDependencies": {
+    "@types/node": "^20.19.33",
+    "openapi-typescript": "^7.6.1",
+    "tsup": "^8.4.0",
+    "typescript": "^5.9.3"
   },
-  "bugs": {
-    "url": "https://github.com/jhermsmeier/node-disk/issues"
+  "engines": {
+    "node": ">= 18"
   },
-  "directories": {
-    "test": "test"
-  }
+  "keywords": [
+    "archil",
+    "disk",
+    "filesystem",
+    "cli"
+  ],
+  "license": "MIT"
 }