hypha-cli 0.1.11 → 0.1.12

package/dist/cli.mjs

@@ -77,37 +77,37 @@ async function main() {
   }
   const commandArgs = args.slice(1);
   if (subcommand === "login") {
-    const { loginCommand } = await import('./workspace-DDljPOfV.mjs');
+    const { loginCommand } = await import('./workspace-DE2jBAXs.mjs');
     await loginCommand(commandArgs);
   } else if (subcommand === "token") {
-    const { tokenCommand } = await import('./workspace-DDljPOfV.mjs');
+    const { tokenCommand } = await import('./workspace-DE2jBAXs.mjs');
     await tokenCommand(commandArgs);
   } else if (subcommand === "services") {
-    const { servicesCommand } = await import('./workspace-DDljPOfV.mjs');
+    const { servicesCommand } = await import('./workspace-DE2jBAXs.mjs');
     await servicesCommand(commandArgs);
   } else if (subcommand === "info") {
-    const { infoCommand } = await import('./workspace-DDljPOfV.mjs');
+    const { infoCommand } = await import('./workspace-DE2jBAXs.mjs');
     await infoCommand(commandArgs);
   } else if (subcommand === "clients") {
-    const { clientsCommand } = await import('./workspace-DDljPOfV.mjs');
+    const { clientsCommand } = await import('./workspace-DE2jBAXs.mjs');
     await clientsCommand(commandArgs);
   } else if (subcommand === "ping") {
-    const { pingCommand } = await import('./workspace-DDljPOfV.mjs');
+    const { pingCommand } = await import('./workspace-DE2jBAXs.mjs');
     await pingCommand(commandArgs);
   } else if (subcommand === "kick") {
-    const { kickCommand } = await import('./workspace-DDljPOfV.mjs');
+    const { kickCommand } = await import('./workspace-DE2jBAXs.mjs');
     await kickCommand(commandArgs);
   } else if (subcommand === "cleanup") {
-    const { cleanupCommand } = await import('./workspace-DDljPOfV.mjs');
+    const { cleanupCommand } = await import('./workspace-DE2jBAXs.mjs');
     await cleanupCommand(commandArgs);
   } else if (subcommand === "workspace-info") {
-    const { workspaceInfoCommand } = await import('./workspace-DDljPOfV.mjs');
+    const { workspaceInfoCommand } = await import('./workspace-DE2jBAXs.mjs');
     await workspaceInfoCommand(commandArgs);
   } else if (subcommand === "apps") {
-    const { handleAppsCommand } = await import('./apps-BJCjouF4.mjs');
+    const { handleAppsCommand } = await import('./apps-D9WCfzIl.mjs');
     await handleAppsCommand(commandArgs);
   } else if (subcommand === "artifacts" || subcommand === "art") {
-    const { handleArtifactsCommand } = await import('./artifacts-B-iBR64g.mjs');
+    const { handleArtifactsCommand } = await import('./artifacts-DHPJIrSS.mjs');
     await handleArtifactsCommand(commandArgs);
   } else {
     console.error(`Unknown command: ${subcommand}`);

package/dist/helpers-BC4AKy6a.mjs

@@ -0,0 +1,224 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+function getHyphaHome() {
+  return process.env.HYPHA_HOME || join(homedir(), ".hypha");
+}
+function getEnvFilePath() {
+  return join(getHyphaHome(), ".env");
+}
+function readEnvValue(key) {
+  const envFile = getEnvFilePath();
+  if (!existsSync(envFile)) return void 0;
+  const lines = readFileSync(envFile, "utf-8").split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eqIdx = trimmed.indexOf("=");
+    if (eqIdx === -1) continue;
+    const k = trimmed.slice(0, eqIdx).trim();
+    const v = trimmed.slice(eqIdx + 1).trim().replace(/^["']|["']$/g, "");
+    if (k === key) return v;
+  }
+  return void 0;
+}
+function writeEnvValue(key, value) {
+  const envFile = getEnvFilePath();
+  const dir = getHyphaHome();
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  let lines = [];
+  if (existsSync(envFile)) {
+    lines = readFileSync(envFile, "utf-8").split("\n");
+  }
+  let found = false;
+  for (let i = 0; i < lines.length; i++) {
+    const trimmed = lines[i].trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eqIdx = trimmed.indexOf("=");
+    if (eqIdx === -1) continue;
+    if (trimmed.slice(0, eqIdx).trim() === key) {
+      lines[i] = `${key}=${value}`;
+      found = true;
+      break;
+    }
+  }
+  if (!found) {
+    lines.push(`${key}=${value}`);
+  }
+  writeFileSync(envFile, lines.join("\n") + "\n", { mode: 384 });
+}
+function resolveServerUrl(opts) {
+  return opts?.serverUrl || process.env.HYPHA_SERVER_URL || readEnvValue("HYPHA_SERVER_URL") || "https://hypha.aicell.io";
+}
+function resolveToken(opts) {
+  return opts?.token || process.env.HYPHA_TOKEN || readEnvValue("HYPHA_TOKEN");
+}
+function resolveWorkspace(opts) {
+  return opts?.workspace || process.env.HYPHA_WORKSPACE || readEnvValue("HYPHA_WORKSPACE");
+}
+async function connectToHypha(opts) {
+  const serverUrl = resolveServerUrl(opts);
+  const token = resolveToken(opts);
+  const workspace = resolveWorkspace(opts);
+  if (!token) {
+    const envFile = getEnvFilePath();
+    console.error("No HYPHA_TOKEN found.");
+    console.error(`  Looked in: process.env.HYPHA_TOKEN, ${envFile}`);
+    console.error("  Fix: run `hypha login`, or set HYPHA_TOKEN in the environment / that file.");
+    process.exit(1);
+  }
+  const { hyphaWebsocketClient } = await import('hypha-rpc');
+  let server;
+  try {
+    server = await hyphaWebsocketClient.connectToServer({
+      server_url: serverUrl,
+      token,
+      workspace: workspace || void 0,
+      // Suppress hypha-rpc connection/disconnection log noise
+      logger: null
+    });
+  } catch (err) {
+    const msg = String(err?.message || err);
+    if (workspace && /workspace/i.test(msg) && /(mismatch|denied|permission|forbidden|not allowed|unauthorized)/i.test(msg)) {
+      console.error(`Workspace '${workspace}' was requested but the token does not grant it.`);
+      console.error(`  Source of override: process.env.HYPHA_WORKSPACE or ${getEnvFilePath()}`);
+      console.error("  Fix: run `hypha login` to refresh credentials, or unset HYPHA_WORKSPACE.");
+      console.error(`  (server said: ${msg})`);
+      process.exit(1);
+    }
+    throw err;
+  }
+  return server;
+}
+async function loginToHypha(serverUrl) {
+  const url = serverUrl || resolveServerUrl();
+  const { hyphaWebsocketClient } = await import('hypha-rpc');
+  console.log(`Logging in to ${url}...`);
+  const token = await hyphaWebsocketClient.login({
+    server_url: url,
+    logger: null
+  });
+  if (!token) {
+    console.error("Login failed \u2014 no token received.");
+    process.exit(1);
+  }
+  const server = await hyphaWebsocketClient.connectToServer({
+    server_url: url,
+    token,
+    logger: null
+  });
+  const ws = server.config.workspace;
+  writeEnvValue("HYPHA_SERVER_URL", url);
+  writeEnvValue("HYPHA_TOKEN", token);
+  writeEnvValue("HYPHA_WORKSPACE", ws);
+  console.log(`Logged in to workspace: ${ws}`);
+  console.log(`Credentials saved to ${getEnvFilePath()}`);
+  await server.disconnect();
+}
+
+function getFlag(args, flag, shortFlag) {
+  for (let i = 0; i < args.length; i++) {
+    if ((args[i] === flag || shortFlag && args[i] === shortFlag) && i + 1 < args.length) {
+      return args[i + 1];
+    }
+  }
+  return void 0;
+}
+function getFlagInt(args, flag, shortFlag) {
+  const val = getFlag(args, flag, shortFlag);
+  if (val === void 0) return void 0;
+  const n = parseInt(val, 10);
+  return isNaN(n) ? void 0 : n;
+}
+function getAllFlags(args, flag) {
+  const results = [];
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === flag && i + 1 < args.length) {
+      results.push(args[i + 1]);
+      i++;
+    }
+  }
+  return results;
+}
+function hasFlag(args, ...flags) {
+  return args.some((a) => flags.includes(a));
+}
+function positionalArgs(args, knownFlags = []) {
+  const result = [];
+  for (let i = 0; i < args.length; i++) {
+    if (args[i].startsWith("-")) {
+      if (knownFlags.includes(args[i]) && i + 1 < args.length) {
+        i++;
+      }
+      continue;
+    }
+    result.push(args[i]);
+  }
+  return result;
+}
+function formatJson(data) {
+  return JSON.stringify(data, null, 2);
+}
+function formatTable(rows) {
+  if (rows.length === 0) return "";
+  const colCount = rows[0].length;
+  const widths = new Array(colCount).fill(0);
+  for (const row of rows) {
+    for (let i = 0; i < row.length; i++) {
+      widths[i] = Math.max(widths[i], (row[i] || "").length);
+    }
+  }
+  return rows.map(
+    (row) => row.map((cell, i) => (cell || "").padEnd(widths[i])).join("  ")
+  ).join("\n");
+}
+function humanSize(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+  return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
+}
+function relativeTime(timestamp) {
+  const diff = Date.now() - timestamp;
+  const seconds = Math.floor(diff / 1e3);
+  if (seconds < 60) return `${seconds}s ago`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}m ago`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  return `${days}d ago`;
+}
+function printProgress(label, current, total) {
+  if (total <= 0) return;
+  const pct = Math.min(100, Math.round(current / total * 100));
+  const barWidth = 30;
+  const filled = Math.round(barWidth * (current / total));
+  const bar = "=".repeat(filled) + (filled < barWidth ? ">" : "") + " ".repeat(Math.max(0, barWidth - filled - 1));
+  const sizeStr = `${humanSize(current)}/${humanSize(total)}`;
+  const maxLabel = 25;
+  const displayLabel = label.length > maxLabel ? "..." + label.slice(-22) : label;
+  process.stderr.write(`\r  ${displayLabel.padEnd(maxLabel)} [${bar}] ${pct}% ${sizeStr}  `);
+  if (current >= total) {
+    process.stderr.write("\n");
+  }
+}
+function printAggregateProgress(label, filesDone, filesTotal, bytesDone, bytesTotal) {
+  if (filesTotal <= 0) return;
+  const pct = Math.min(100, Math.round(filesDone / filesTotal * 100));
+  const barWidth = 30;
+  const filled = Math.round(barWidth * (filesDone / filesTotal));
+  const bar = "=".repeat(filled) + (filled < barWidth ? ">" : "") + " ".repeat(Math.max(0, barWidth - filled - 1));
+  const sizeStr = bytesTotal > 0 ? ` ${humanSize(bytesDone)}/${humanSize(bytesTotal)}` : "";
+  const maxLabel = 20;
+  const displayLabel = label.length > maxLabel ? "..." + label.slice(-17) : label;
+  process.stderr.write(
+    `\r  ${displayLabel.padEnd(maxLabel)} [${bar}] ${pct}% ${filesDone}/${filesTotal} files${sizeStr}  `
+  );
+  if (filesDone >= filesTotal) {
+    process.stderr.write("\n");
+  }
+}
+
+export { formatTable as a, resolveToken as b, connectToHypha as c, resolveWorkspace as d, hasFlag as e, formatJson as f, getFlagInt as g, humanSize as h, getFlag as i, relativeTime as j, getAllFlags as k, loginToHypha as l, printAggregateProgress as m, printProgress as n, positionalArgs as p, resolveServerUrl as r };

package/dist/index.mjs

@@ -1,4 +1,4 @@
-export { c as connectToHypha, f as formatJson, a as formatTable, h as humanSize, l as loginToHypha, r as resolveServerUrl, b as resolveToken, d as resolveWorkspace } from './helpers-DWQC3Lr8.mjs';
+export { c as connectToHypha, f as formatJson, a as formatTable, h as humanSize, l as loginToHypha, r as resolveServerUrl, b as resolveToken, d as resolveWorkspace } from './helpers-BC4AKy6a.mjs';
 export { d as determineCpDirection, i as isArtifactPath, p as parseArtifactPath } from './artifactPath-DCtvp6Go.mjs';
 import 'fs';
 import 'path';

package/dist/workspace-DE2jBAXs.mjs

@@ -0,0 +1,286 @@
+import { e as hasFlag, l as loginToHypha, c as connectToHypha, g as getFlagInt, i as getFlag, f as formatJson, a as formatTable, r as resolveServerUrl } from './helpers-BC4AKy6a.mjs';
+import 'fs';
+import 'path';
+import 'os';
+
+async function loginCommand(args) {
+  if (hasFlag(args, "--help", "-h")) {
+    console.log(`Usage: hypha login [server-url]
+
+Login to a Hypha server via browser-based OAuth.
+Credentials are saved to ~/.hypha/.env.
+
+Default server: https://hypha.aicell.io`);
+    return;
+  }
+  const serverUrl = args[0] && !args[0].startsWith("-") ? args[0] : void 0;
+  await loginToHypha(serverUrl);
+}
+async function tokenCommand(args) {
+  if (hasFlag(args, "--help", "-h")) {
+    console.log(`Usage: hypha token [options]
+
+Generate a workspace token.
+
+Options:
+  --expires-in <seconds>     Token expiration (default: 3600)
+  --permission <perm>        Permission level: read, read_write, admin (default: read_write)
+  --workspace <ws>           Target workspace (default: current)
+  --json                     Output as JSON`);
+    return;
+  }
+  const server = await connectToHypha();
+  try {
+    const expiresIn = getFlagInt(args, "--expires-in") || 3600;
+    const permission = getFlag(args, "--permission") || "read_write";
+    const workspace = getFlag(args, "--workspace") || server.config.workspace;
+    const json = hasFlag(args, "--json");
+    const token = await server.generateToken({
+      expires_in: expiresIn,
+      permission,
+      workspace
+    });
+    if (json) {
+      console.log(formatJson({
+        token,
+        workspace,
+        permission,
+        expires_in: expiresIn
+      }));
+    } else {
+      console.log(token);
+    }
+  } finally {
+    await server.disconnect();
+  }
+}
+async function servicesCommand(args) {
+  if (hasFlag(args, "--help", "-h")) {
+    console.log(`Usage: hypha services [options]
+
+List services in the current workspace.
+
+Options:
+  --type <type>              Filter by service type
+  --include-unlisted         Include unlisted services
+  --json                     Output as JSON`);
+    return;
+  }
+  const server = await connectToHypha();
+  try {
+    const type = getFlag(args, "--type");
+    const includeUnlisted = hasFlag(args, "--include-unlisted");
+    const json = hasFlag(args, "--json");
+    const query = { _rkwargs: true };
+    if (type) query.type = type;
+    if (includeUnlisted) query.include_unlisted = true;
+    const services = await server.listServices(query);
+    if (json) {
+      console.log(formatJson(services));
+      return;
+    }
+    if (!services || services.length === 0) {
+      console.log("No services found.");
+      return;
+    }
+    const rows = [["ID", "NAME", "TYPE", "DESCRIPTION"]];
+    for (const svc of services) {
+      rows.push([
+        svc.id || "",
+        svc.name || "",
+        svc.type || "",
+        (svc.description || "").slice(0, 60)
+      ]);
+    }
+    console.log(formatTable(rows));
+  } finally {
+    await server.disconnect();
+  }
+}
+async function clientsCommand(args) {
+  if (hasFlag(args, "--help", "-h")) {
+    console.log(`Usage: hypha clients [workspace] [options]
+
+List connected clients in a workspace. Defaults to the connected workspace.
+Pass a workspace name as positional arg to target a different workspace (requires admin).
+
+Options:
+  --json                     Output as JSON`);
+    return;
+  }
+  const server = await connectToHypha();
+  try {
+    const json = hasFlag(args, "--json");
+    const targetWs = args[0] && !args[0].startsWith("-") ? args[0] : server.config.workspace;
+    const clients = await server.listClients({ workspace: targetWs, _rkwargs: true });
+    if (json) {
+      console.log(formatJson(clients));
+      return;
+    }
+    console.log(`${clients.length} client(s) in workspace ${targetWs}`);
+    if (clients.length === 0) return;
+    for (const c of clients.slice(0, 50)) {
+      const id = typeof c === "string" ? c : c.id || String(c);
+      const email = typeof c === "object" ? c.user?.email || "" : "";
+      console.log(`  ${id}${email ? "  (" + email + ")" : ""}`);
+    }
+    if (clients.length > 50) {
+      console.log(`  ... and ${clients.length - 50} more`);
+    }
+  } finally {
+    await server.disconnect();
+  }
+}
+async function pingCommand(args) {
+  if (hasFlag(args, "--help", "-h")) {
+    console.log(`Usage: hypha ping <client-id> [options]
+
+Ping a specific client to check if it's alive.
+
+Options:
+  --timeout <seconds>        Ping timeout (default: 5)`);
+    return;
+  }
+  const clientId = args[0] && !args[0].startsWith("-") ? args[0] : void 0;
+  if (!clientId) {
+    console.error("Usage: hypha ping <client-id>");
+    process.exit(1);
+  }
+  const server = await connectToHypha();
+  try {
+    const timeout = getFlagInt(args, "--timeout") || 5;
+    try {
+      const result = await server.ping({ client_id: clientId, timeout, _rkwargs: true });
+      console.log(`${clientId}: ${result}`);
+    } catch (e) {
+      console.log(`${clientId}: dead (${e.message || e})`);
+    }
+  } finally {
+    await server.disconnect();
+  }
+}
+async function kickCommand(args) {
+  if (hasFlag(args, "--help", "-h")) {
+    console.log(`Usage: hypha kick <client-id> [workspace]
+
+Disconnect a client and remove all its services. Requires admin.
+If workspace is not specified, uses the connected workspace.
+
+Note: delete_client is not in the default workspace interface.
+This command uses the workspace-manager service directly.`);
+    return;
+  }
+  const clientId = args[0] && !args[0].startsWith("-") ? args[0] : void 0;
+  if (!clientId) {
+    console.error("Usage: hypha kick <client-id> [workspace]");
+    process.exit(1);
+  }
+  const server = await connectToHypha();
+  try {
+    const targetWs = args[1] && !args[1].startsWith("-") ? args[1] : server.config.workspace;
+    const svc = await server.getService(`${server.config.workspace}/*:default`);
+    if (svc.deleteClient) {
+      await svc.deleteClient({ client_id: clientId, workspace: targetWs, _rkwargs: true });
+    } else {
+      console.error("delete_client is not available. Use `hypha cleanup` instead.");
+      process.exit(1);
+    }
+    console.log(`Kicked client ${clientId} from ${targetWs}`);
+  } finally {
+    await server.disconnect();
+  }
+}
+async function cleanupCommand(args) {
+  if (hasFlag(args, "--help", "-h")) {
+    console.log(`Usage: hypha cleanup [workspace] [options]
+
+Ping all clients in a workspace and remove dead/stale ones.
+Requires admin permission.
+Defaults to the connected workspace. Pass workspace name as positional arg.
+
+Options:
+  --timeout <seconds>        Ping timeout per client (default: 2)
+  --json                     Output as JSON`);
+    return;
+  }
+  const server = await connectToHypha();
+  try {
+    const timeout = getFlagInt(args, "--timeout") || 2;
+    const json = hasFlag(args, "--json");
+    const targetWs = args[0] && !args[0].startsWith("-") ? args[0] : server.config.workspace;
+    const clients = await server.listClients({ workspace: targetWs, _rkwargs: true });
+    console.log(`Workspace ${targetWs}: ${clients.length} client(s)`);
+    console.log(`Pinging all clients (timeout=${timeout}s)... this may take a while.`);
+    const result = await server.cleanup({ workspace: targetWs, timeout, _rkwargs: true });
+    const removed = result?.removed_clients || result?.removedClients || [];
+    if (json) {
+      console.log(formatJson(result));
+    } else {
+      console.log(`Removed ${removed.length} dead client(s).`);
+      if (removed.length > 0 && removed.length <= 30) {
+        for (const c of removed) {
+          console.log(`  - ${c}`);
+        }
+      }
+      if (result?.removed_workspace || result?.removedWorkspace) {
+        console.log(`Workspace ${targetWs} was removed (no live clients remaining).`);
+      }
+    }
+  } finally {
+    await server.disconnect();
+  }
+}
+async function workspaceInfoCommand(args) {
+  if (hasFlag(args, "--help", "-h")) {
+    console.log(`Usage: hypha workspace-info [workspace] [--json]
+
+Show detailed workspace information (admin).`);
+    return;
+  }
+  const server = await connectToHypha();
+  try {
+    const json = hasFlag(args, "--json");
+    const targetWs = args[0] && !args[0].startsWith("-") ? args[0] : server.config.workspace;
+    const wsInfo = await server.getWorkspaceInfo({ workspace: targetWs, _rkwargs: true });
+    if (json) {
+      console.log(formatJson(wsInfo));
+    } else {
+      console.log(`Workspace: ${wsInfo.id || wsInfo.name || targetWs}`);
+      for (const [k, v] of Object.entries(wsInfo)) {
+        if (k === "id" || k === "name") continue;
+        const val = typeof v === "object" ? JSON.stringify(v) : String(v);
+        console.log(`  ${k}: ${val.slice(0, 120)}`);
+      }
+    }
+  } finally {
+    await server.disconnect();
+  }
+}
+async function infoCommand(args) {
+  if (hasFlag(args, "--help", "-h")) {
+    console.log(`Usage: hypha info [--json]
+
+Show connection information.`);
+    return;
+  }
+  const server = await connectToHypha();
+  try {
+    const json = hasFlag(args, "--json");
+    const info = {
+      server_url: server.config.public_base_url || resolveServerUrl(),
+      workspace: server.config.workspace,
+      client_id: server.config.client_id
+    };
+    if (json) {
+      console.log(formatJson(info));
+    } else {
+      console.log(`Server:    ${info.server_url}`);
+      console.log(`Workspace: ${info.workspace}`);
+      console.log(`Client ID: ${info.client_id}`);
+    }
+  } finally {
+    await server.disconnect();
+  }
+}
+
+export { cleanupCommand, clientsCommand, infoCommand, kickCommand, loginCommand, pingCommand, servicesCommand, tokenCommand, workspaceInfoCommand };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "hypha-cli",
-    "version": "0.1.11",
+    "version": "0.1.12",
     "description": "Hypha Cloud CLI — manage workspaces, apps, and artifacts",
     "author": "Amun AI AB",
     "license": "SEE LICENSE IN LICENSE",
@@ -21,7 +21,7 @@
         "postinstall": "node bin/postinstall.mjs",
         "build": "tsc --noEmit && pkgroll",
         "typecheck": "tsc --noEmit",
-        "test": "npx tsx test/test-cli-routing.mjs && npx tsx test/test-artifact-path.mjs && npx tsx test/test-apps-commands.mjs && npx tsx test/test-artifacts-commands.mjs && npx tsx test/test-helpers.mjs",
+        "test": "npx tsx test/test-cli-routing.mjs && npx tsx test/test-artifact-path.mjs && npx tsx test/test-apps-commands.mjs && npx tsx test/test-artifacts-commands.mjs && npx tsx test/test-helpers.mjs && npx tsx test/test-transfer.mjs",
         "test:integration": "npx tsx test/test-integration.mjs",
         "dev": "tsx src/cli.ts"
     },