hypha-cli 0.1.0

package/dist/cli.mjs

@@ -0,0 +1,99 @@
+const nodeMajor = parseInt(process.versions.node.split(".")[0], 10);
+if (nodeMajor < 22) {
+  console.error(`Error: hypha requires Node.js >= 22 (you have ${process.version}).`);
+  process.exit(1);
+}
+const args = process.argv.slice(2);
+function extractGlobalFlag(argList, flag) {
+  const idx = argList.indexOf(flag);
+  if (idx === -1 || idx >= argList.length - 1) return void 0;
+  const value = argList[idx + 1];
+  argList.splice(idx, 2);
+  return value;
+}
+const globalServer = extractGlobalFlag(args, "--server");
+const globalWorkspace = extractGlobalFlag(args, "--workspace");
+if (globalServer) process.env.HYPHA_SERVER_URL = globalServer;
+if (globalWorkspace) process.env.HYPHA_WORKSPACE = globalWorkspace;
+const subcommand = args[0];
+function printHelp() {
+  console.log(`hypha \u2014 Hypha Cloud CLI
+
+Usage: hypha [--server URL] [--workspace WS] <command> [options]
+
+Workspace:
+  login [server-url]             Login to Hypha server (opens browser)
+  token [options]                Generate a workspace token
+  services [options]             List services in workspace
+  info                           Show workspace info
+
+Apps (manage server app definitions and instances):
+  apps list [--json]             List installed app definitions
+  apps info <app-id>             Show app details
+  apps install <source>          Install an app
+  apps uninstall <app-id>        Remove an app (alias: rm)
+  apps start <app-id>            Start an app instance
+  apps stop <id> [--all]         Stop instance(s)
+  apps ps [--json]               List running instances
+  apps logs <instance-id>        View instance logs
+
+Artifacts (manage data, models, and files):
+  artifacts ls [artifact[:path]] List artifacts or files (alias: list)
+  artifacts cat <artifact:path>  Read file to stdout
+  artifacts cp <src> <dest>      Upload/download files (scp-style)
+  artifacts rm <artifact[:path]> Delete artifact or file
+  artifacts create <alias>       Create a new artifact (alias: mkdir)
+  artifacts info <artifact>      Show artifact metadata
+  artifacts search <query>       Search artifacts (alias: find)
+  artifacts commit <artifact>    Commit staged changes
+  artifacts edit <artifact>      Edit artifact metadata
+  artifacts discard <artifact>   Discard staged changes
+
+Global options:
+  --server <url>                 Hypha server URL (overrides env/config)
+  --workspace <ws>               Workspace ID (overrides env/config)
+  --help, -h                     Show help
+  --version, -v                  Show version
+
+Shorthand: "art" is an alias for "artifacts".
+Config: ~/.hypha/.env (HYPHA_SERVER_URL, HYPHA_TOKEN, HYPHA_WORKSPACE)`);
+}
+async function main() {
+  if (!subcommand || subcommand === "--help" || subcommand === "-h") {
+    printHelp();
+    return;
+  }
+  if (subcommand === "--version" || subcommand === "-v") {
+    const version = process.env.HYPHA_CLI_VERSION || "0.1.0";
+    console.log(`hypha-cli ${version}`);
+    return;
+  }
+  const commandArgs = args.slice(1);
+  if (subcommand === "login") {
+    const { loginCommand } = await import('./workspace-wlyR33kp.mjs');
+    await loginCommand(commandArgs);
+  } else if (subcommand === "token") {
+    const { tokenCommand } = await import('./workspace-wlyR33kp.mjs');
+    await tokenCommand(commandArgs);
+  } else if (subcommand === "services") {
+    const { servicesCommand } = await import('./workspace-wlyR33kp.mjs');
+    await servicesCommand(commandArgs);
+  } else if (subcommand === "info") {
+    const { infoCommand } = await import('./workspace-wlyR33kp.mjs');
+    await infoCommand(commandArgs);
+  } else if (subcommand === "apps") {
+    const { handleAppsCommand } = await import('./apps-rK1_N8nw.mjs');
+    await handleAppsCommand(commandArgs);
+  } else if (subcommand === "artifacts" || subcommand === "art") {
+    const { handleArtifactsCommand } = await import('./artifacts-8p2A4NMr.mjs');
+    await handleArtifactsCommand(commandArgs);
+  } else {
+    console.error(`Unknown command: ${subcommand}`);
+    console.error("Run `hypha --help` for usage.");
+    process.exit(1);
+  }
+}
+main().catch((err) => {
+  console.error(err.message || err);
+  process.exit(1);
+});

package/dist/helpers-BvfSCkvr.mjs

@@ -0,0 +1,188 @@
+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) {
+    console.error("No token found. Run `hypha login` first, or set HYPHA_TOKEN.");
+    process.exit(1);
+  }
+  const { hyphaWebsocketClient } = await import('hypha-rpc');
+  const server = await hyphaWebsocketClient.connectToServer({
+    server_url: serverUrl,
+    token,
+    workspace: workspace || void 0
+  });
+  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
+  });
+  if (!token) {
+    console.error("Login failed \u2014 no token received.");
+    process.exit(1);
+  }
+  const server = await hyphaWebsocketClient.connectToServer({
+    server_url: url,
+    token
+  });
+  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");
+  }
+}
+
+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, printProgress as m, positionalArgs as p, resolveServerUrl as r };

package/dist/index.mjs

@@ -0,0 +1,5 @@
+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-BvfSCkvr.mjs';
+export { d as determineCpDirection, i as isArtifactPath, p as parseArtifactPath } from './artifactPath-DCtvp6Go.mjs';
+import 'fs';
+import 'path';
+import 'os';

package/dist/workspace-wlyR33kp.mjs

@@ -0,0 +1,127 @@
+import { e as hasFlag, l as loginToHypha, c as connectToHypha, g as getFlagInt, i as getFlag, f as formatJson, a as formatTable } from './helpers-BvfSCkvr.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 infoCommand(args) {
+  if (hasFlag(args, "--help", "-h")) {
+    console.log(`Usage: hypha info [--json]
+
+Show workspace information.`);
+    return;
+  }
+  const server = await connectToHypha();
+  try {
+    const json = hasFlag(args, "--json");
+    const info = {
+      server_url: server.config.server_url,
+      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 { infoCommand, loginCommand, servicesCommand, tokenCommand };

package/package.json

@@ -0,0 +1,36 @@
+{
+    "name": "hypha-cli",
+    "version": "0.1.0",
+    "description": "Hypha Cloud CLI — manage workspaces, apps, and artifacts",
+    "author": "Amun AI AB",
+    "license": "SEE LICENSE IN LICENSE",
+    "type": "module",
+    "bin": {
+        "hypha": "./bin/hypha.mjs"
+    },
+    "files": [
+        "dist",
+        "bin"
+    ],
+    "main": "./dist/index.mjs",
+    "exports": {
+        ".": "./dist/index.mjs",
+        "./cli": "./dist/cli.mjs"
+    },
+    "scripts": {
+        "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:integration": "npx tsx test/test-integration.mjs",
+        "dev": "tsx src/cli.ts"
+    },
+    "dependencies": {
+        "hypha-rpc": "0.21.29"
+    },
+    "devDependencies": {
+        "@types/node": ">=20",
+        "pkgroll": "^2.14.2",
+        "tsx": "^4.20.6",
+        "typescript": "5.9.3"
+    }
+}