disk 0.8.0 → 0.8.9

package/dist/cli.js

@@ -0,0 +1,592 @@
+#!/usr/bin/env node
+
+// bin/cli.ts
+import { createRequire as createRequire2 } from "module";
+import { Command, Option } from "commander";
+
+// 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, name: opts?.name } }
+      })
+    );
+    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);
+}
+
+// bin/cli.ts
+var pkg = createRequire2(import.meta.url)("../package.json");
+var program = new Command();
+program.name("disk").description("Manage Archil disks from the command line").version(pkg.version).addOption(new Option("-k, --api-key <key>", "Archil API key").env("ARCHIL_API_KEY")).addOption(new Option("-r, --region <region>", "Archil region").env("ARCHIL_REGION")).addOption(new Option("--base-url <url>", "Override control-plane base URL")).hook("preAction", () => {
+  const opts = program.opts();
+  try {
+    configure({ apiKey: opts.apiKey, region: opts.region, baseUrl: opts.baseUrl });
+  } catch (err) {
+    fail(err);
+  }
+});
+function fail(err) {
+  if (err instanceof ArchilApiError) {
+    console.error(`Error (${err.status}): ${err.message}`);
+  } else {
+    console.error(err instanceof Error ? err.message : String(err));
+  }
+  process.exit(1);
+}
+function isDiskId(s) {
+  return /^(dsk-|fs-)[0-9a-fA-F]+$/.test(s);
+}
+async function resolveDisk(idOrName) {
+  if (isDiskId(idOrName)) {
+    return getDisk(idOrName);
+  }
+  const matches = await listDisks({ name: idOrName });
+  if (matches.length === 0) {
+    throw new ArchilApiError(`No disk found with name '${idOrName}'`, 404);
+  }
+  if (matches.length > 1) {
+    throw new ArchilApiError(
+      `Multiple disks match name '${idOrName}' \u2014 pass a disk id (dsk-...) instead`,
+      400
+    );
+  }
+  return matches[0];
+}
+function formatBytes(n) {
+  if (n === void 0 || n === null) return void 0;
+  if (n < 1024) return `${n} B`;
+  const units = ["KB", "MB", "GB", "TB", "PB"];
+  let v = n / 1024;
+  let i = 0;
+  while (v >= 1024 && i < units.length - 1) {
+    v /= 1024;
+    i++;
+  }
+  return `${v.toFixed(v >= 100 ? 0 : v >= 10 ? 1 : 2)} ${units[i]}`;
+}
+function renderTable(rows, headers) {
+  const all = headers ? [headers, ...rows] : rows;
+  if (all.length === 0) return "";
+  const cols = Math.max(...all.map((r) => r.length));
+  const widths = [];
+  for (let i = 0; i < cols; i++) {
+    widths[i] = Math.max(...all.map((r) => (r[i] ?? "").length));
+  }
+  const bar = (l, m, r) => l + widths.map((w) => "\u2500".repeat(w + 2)).join(m) + r;
+  const line = (r) => "\u2502 " + widths.map((w, i) => (r[i] ?? "").padEnd(w)).join(" \u2502 ") + " \u2502";
+  const out = [bar("\u256D", "\u252C", "\u256E")];
+  if (headers) {
+    out.push(line(headers));
+    out.push(bar("\u251C", "\u253C", "\u2524"));
+  }
+  for (const r of rows) out.push(line(r));
+  out.push(bar("\u2570", "\u2534", "\u256F"));
+  return out.join("\n");
+}
+function section(title, body) {
+  console.log("");
+  console.log(title);
+  console.log(body);
+}
+function printDisk(d) {
+  console.log(`${d.organization}/${d.name}  (${d.id})`);
+  const kv = [
+    ["status", d.status],
+    ["provider", d.provider],
+    ["region", d.region],
+    ["created", d.createdAt],
+    ["last accessed", d.lastAccessed],
+    ["data size", formatBytes(d.dataSize)],
+    ["monthly usage", d.monthlyUsage]
+  ];
+  const visible = kv.filter(([, v]) => v !== void 0 && v !== null && v !== "").map(([k, v]) => [k, String(v)]);
+  console.log("");
+  console.log(renderTable(visible));
+  if (d.mounts && d.mounts.length > 0) {
+    const rows = d.mounts.map((m) => [
+      m.type ?? "?",
+      m.name ?? m.path ?? "",
+      m.accessMode ?? ""
+    ]);
+    section("Mounts", renderTable(rows, ["type", "location", "mode"]));
+  }
+  if (d.authorizedUsers && d.authorizedUsers.length > 0) {
+    const rows = d.authorizedUsers.map((u) => {
+      if (u.type === "token") {
+        return ["token", u.nickname ?? "(no name)", u.tokenSuffix ? `-${u.tokenSuffix}` : ""];
+      }
+      return [u.type ?? "?", u.identifier ?? u.principal ?? "", ""];
+    });
+    section("Authorized users", renderTable(rows, ["type", "name / identifier", "suffix"]));
+  }
+  if (d.connectedClients && d.connectedClients.length > 0) {
+    const rows = d.connectedClients.map((c) => [
+      c.id ?? "",
+      c.ipAddress ?? "",
+      c.connectedAt ?? ""
+    ]);
+    section("Connected clients", renderTable(rows, ["id", "ip", "connected at"]));
+  }
+}
+program.command("list").description("List disks in the current region").option("--limit <n>", "Maximum number of disks to return", (v) => parseInt(v, 10)).option("-o, --output <format>", "Output format: table | json", "table").action(async (opts) => {
+  try {
+    const disks = await listDisks({ limit: opts.limit });
+    if (opts.output === "json") {
+      console.log(JSON.stringify(disks, null, 2));
+      return;
+    }
+    if (disks.length === 0) {
+      console.log("No disks found.");
+      return;
+    }
+    const rows = disks.map((d) => [d.id, `${d.organization}/${d.name}`, d.status]);
+    console.log(renderTable(rows, ["id", "name", "status"]));
+  } catch (err) {
+    fail(err);
+  }
+});
+program.command("get <id|name>").description("Show details for a disk (accepts a disk id or name)").option("-o, --output <format>", "Output format: table | json", "table").action(async (idOrName, opts) => {
+  try {
+    const d = await resolveDisk(idOrName);
+    if (opts.output === "json") {
+      console.log(JSON.stringify(d, null, 2));
+    } else {
+      printDisk(d);
+    }
+  } catch (err) {
+    fail(err);
+  }
+});
+program.command("create <name>").description("Create a new disk").action(async (name) => {
+  try {
+    const result = await createDisk({ name });
+    console.log(`Created disk ${result.disk.organization}/${result.disk.name}`);
+    console.log(`  id:     ${result.disk.id}`);
+    console.log(`  status: ${result.disk.status}`);
+    if (result.token) {
+      console.log("");
+      console.log("Disk token (save this \u2014 it cannot be retrieved again):");
+      console.log(`  ${result.token}`);
+      if (result.tokenIdentifier) {
+        console.log(`  identifier: ${result.tokenIdentifier}`);
+      }
+    }
+  } catch (err) {
+    fail(err);
+  }
+});
+program.command("delete <id|name>").description("Delete a disk (accepts a disk id or name)").action(async (idOrName) => {
+  try {
+    const d = await resolveDisk(idOrName);
+    await d.delete();
+    console.log(`Deleted ${d.organization}/${d.name} (${d.id})`);
+  } catch (err) {
+    fail(err);
+  }
+});
+program.command("exec <id|name> <command...>").description("Run a command in a container with the disk mounted, return stdout/stderr/exit code (accepts a disk id or name)").action(async (idOrName, cmd) => {
+  try {
+    const d = await resolveDisk(idOrName);
+    const result = await d.exec(cmd.join(" "));
+    if (result.stdout) process.stdout.write(result.stdout);
+    if (result.stderr) process.stderr.write(result.stderr);
+    process.exit(result.exitCode);
+  } catch (err) {
+    fail(err);
+  }
+});
+var keys = program.command("api-keys").description("Manage Archil API keys (account-level credentials)");
+keys.command("list").description("List API keys").option("--limit <n>", "Maximum number of keys to return", (v) => parseInt(v, 10)).action(async (opts) => {
+  try {
+    const ks = await listApiKeys({ limit: opts.limit });
+    if (ks.length === 0) {
+      console.log("No API keys found.");
+      return;
+    }
+    for (const k of ks) {
+      console.log(`${k.id ?? "-"}	${k.name ?? "-"}	${k.createdAt ?? ""}`);
+    }
+  } catch (err) {
+    fail(err);
+  }
+});
+keys.command("create <name>").description("Create a new API key (the key value is shown once)").option("--description <description>", "Optional description").action(async (name, opts) => {
+  try {
+    const k = await createApiKey({ name, description: opts.description });
+    console.log(`Created API key ${name} (${k.id ?? "?"})`);
+    if (k.token) {
+      console.log("");
+      console.log("API key value (save this \u2014 it cannot be retrieved again):");
+      console.log(`  ${k.token}`);
+    }
+  } catch (err) {
+    fail(err);
+  }
+});
+keys.command("delete <id>").description("Delete an API key").action(async (id) => {
+  try {
+    await deleteApiKey(id);
+    console.log(`Deleted API key ${id}`);
+  } catch (err) {
+    fail(err);
+  }
+});
+function rewriteSugar(argv) {
+  const known = /* @__PURE__ */ new Set(["list", "get", "create", "delete", "exec", "api-keys", "help", "--help", "-h", "--version", "-V"]);
+  const head = argv[2];
+  const next = argv[3];
+  if (head && next === "exec" && !known.has(head) && !head.startsWith("-")) {
+    return [...argv.slice(0, 2), "exec", head, ...argv.slice(4)];
+  }
+  return argv;
+}
+program.parseAsync(rewriteSugar(process.argv));