hypha-cli 0.1.10 → 0.1.12

package/dist/{apps-rK1_N8nw.mjs → apps-D9WCfzIl.mjs}

@@ -1,6 +1,6 @@
 import { statSync, readFileSync, readdirSync } from 'fs';
 import { join, extname } from 'path';
-import { e as hasFlag, f as formatJson, a as formatTable, p as positionalArgs, j as relativeTime, c as connectToHypha, k as getAllFlags, i as getFlag, g as getFlagInt } from './helpers-BvfSCkvr.mjs';
+import { e as hasFlag, f as formatJson, a as formatTable, p as positionalArgs, j as relativeTime, c as connectToHypha, k as getAllFlags, i as getFlag, g as getFlagInt } from './helpers-BC4AKy6a.mjs';
 import 'os';
 
 const IGNORED_DIRS = /* @__PURE__ */ new Set([
@@ -315,7 +315,7 @@ Alias: hypha apps rm`);
   }
   const [server, serverApps] = await getServerApps();
   try {
-    const artifactManager = await server.getService("artifact-manager");
+    const artifactManager = await server.getService("public/artifact-manager");
     await artifactManager.delete({
       artifact_id: appId,
       _rkwargs: true

package/dist/{artifacts-8p2A4NMr.mjs → artifacts-DHPJIrSS.mjs}

@@ -1,9 +1,25 @@
 import { statSync, readFileSync, mkdirSync, createWriteStream, readdirSync } from 'fs';
 import { join, dirname, basename } from 'path';
-import { e as hasFlag, p as positionalArgs, f as formatJson, a as formatTable, r as resolveServerUrl, i as getFlag, g as getFlagInt, c as connectToHypha, b as resolveToken, m as printProgress, h as humanSize } from './helpers-BvfSCkvr.mjs';
+import { e as hasFlag, p as positionalArgs, f as formatJson, a as formatTable, r as resolveServerUrl, i as getFlag, g as getFlagInt, c as connectToHypha, b as resolveToken, m as printAggregateProgress, n as printProgress, h as humanSize } from './helpers-BC4AKy6a.mjs';
 import { p as parseArtifactPath, b as buildFileUrl, d as determineCpDirection, r as resolveArtifactId } from './artifactPath-DCtvp6Go.mjs';
 import 'os';
 
+function envInt(name, fallback) {
+  const raw = process.env[name];
+  if (!raw) return fallback;
+  const n = parseInt(raw, 10);
+  return Number.isFinite(n) && n > 0 ? n : fallback;
+}
+const DEFAULT_BATCH_SIZE = 200;
+const DEFAULT_CONCURRENCY = 16;
+function chunk(arr, n) {
+  if (n <= 0) throw new Error("chunk size must be positive");
+  const out = [];
+  for (let i = 0; i < arr.length; i += n) {
+    out.push(arr.slice(i, i + n));
+  }
+  return out;
+}
 async function uploadFile(artifactManager, artifactId, localPath, remotePath, onProgress) {
   const stat = statSync(localPath);
   const totalBytes = stat.size;
@@ -78,16 +94,85 @@ async function downloadFile(artifactManager, artifactId, remotePath, localPath,
   });
   onProgress?.({ phase: "complete", bytesTransferred, totalBytes: totalBytes || bytesTransferred, fileName: remotePath });
 }
+async function uploadFilesBatched(artifactManager, artifactId, files, onProgress, opts = {}) {
+  const batchSize = opts.batchSize ?? envInt("HYPHA_UPLOAD_BATCH", DEFAULT_BATCH_SIZE);
+  const concurrency = opts.concurrency ?? envInt("HYPHA_UPLOAD_CONCURRENCY", DEFAULT_CONCURRENCY);
+  const filesTotal = files.length;
+  const bytesTotal = files.reduce((s, f) => s + f.size, 0);
+  let filesDone = 0;
+  let bytesDone = 0;
+  const emit = (currentFile) => {
+    onProgress?.({ filesDone, filesTotal, bytesDone, bytesTotal, currentFile });
+  };
+  emit(filesTotal > 0 ? files[0].remotePath : "");
+  for (const group of chunk(files, batchSize)) {
+    const paths = group.map((f) => f.remotePath);
+    const result = await artifactManager.put_file({
+      artifact_id: artifactId,
+      file_path: paths,
+      _rkwargs: true
+    });
+    let urlMap;
+    if (result && typeof result === "object" && !Array.isArray(result)) {
+      urlMap = result;
+    } else {
+      urlMap = {};
+      for (const f of group) {
+        const u = await artifactManager.put_file({
+          artifact_id: artifactId,
+          file_path: f.remotePath,
+          _rkwargs: true
+        });
+        if (typeof u !== "string") {
+          throw new Error(`put_file returned unexpected value for ${f.remotePath}`);
+        }
+        urlMap[f.remotePath] = u;
+      }
+    }
+    let cursor = 0;
+    const workers = [];
+    const worker = async () => {
+      while (true) {
+        const i = cursor++;
+        if (i >= group.length) return;
+        const f = group[i];
+        const url = urlMap[f.remotePath];
+        if (!url || typeof url !== "string") {
+          throw new Error(`No presigned URL returned for ${f.remotePath}`);
+        }
+        const body = readFileSync(f.localPath);
+        const resp = await fetch(url, {
+          method: "PUT",
+          body,
+          headers: {
+            "Content-Type": "application/octet-stream",
+            "Content-Length": String(f.size)
+          }
+        });
+        if (!resp.ok) {
+          const text = await resp.text().catch(() => "");
+          throw new Error(`Upload failed for ${f.remotePath}: ${resp.status} ${resp.statusText} ${text}`);
+        }
+        filesDone++;
+        bytesDone += f.size;
+        emit(f.remotePath);
+      }
+    };
+    const n = Math.min(concurrency, group.length);
+    for (let w = 0; w < n; w++) workers.push(worker());
+    await Promise.all(workers);
+  }
+  return filesDone;
+}
 async function uploadDirectory(artifactManager, artifactId, localDir, remoteBase, onProgress) {
-  const files = collectLocalFiles(localDir);
-  let uploaded = 0;
-  for (const relPath of files) {
+  const relPaths = collectLocalFiles(localDir);
+  const files = relPaths.map((relPath) => {
     const localPath = join(localDir, relPath);
     const remotePath = remoteBase ? `${remoteBase}/${relPath}` : relPath;
-    await uploadFile(artifactManager, artifactId, localPath, remotePath, onProgress);
-    uploaded++;
-  }
-  return uploaded;
+    const size = statSync(localPath).size;
+    return { localPath, remotePath, size };
+  });
+  return uploadFilesBatched(artifactManager, artifactId, files, onProgress);
 }
 async function downloadDirectory(artifactManager, artifactId, remotePath, localDir, onProgress) {
   const files = await artifactManager.list_files({
@@ -154,6 +239,7 @@ Commands:
   commit <artifact> [options]    Commit staged changes
   edit <artifact> [options]      Edit artifact metadata
   discard <artifact>             Discard staged changes
+  serve <artifact> [options]     Enable/disable static site hosting
 
 Aliases: list \u2192 ls, mkdir \u2192 create, find \u2192 search
 Shorthand: "hypha art" is an alias for "hypha artifacts"
@@ -186,6 +272,11 @@ function makeProgressCallback() {
     }
   };
 }
+function makeBatchProgressCallback(label) {
+  return (p) => {
+    printAggregateProgress(label, p.filesDone, p.filesTotal, p.bytesDone, p.bytesTotal);
+  };
+}
 async function fetchWithAuth(url, init) {
   const token = resolveToken();
   const headers = new Headers(init?.headers);
@@ -214,9 +305,9 @@ Alias: hypha artifacts list`);
   const long = hasFlag(args, "--long", "-l");
   const pos = positionalArgs(args)[0];
   if (!pos) {
-    const { server: server2, am } = await connectAndGetArtifactManager();
+    const { server: server2, am: am2 } = await connectAndGetArtifactManager();
     try {
-      const artifacts = await am.list({
+      const artifacts = await am2.list({
         _rkwargs: true
       });
       const list = Array.isArray(artifacts) ? artifacts : artifacts?.items || [];
@@ -252,9 +343,53 @@ Alias: hypha artifacts list`);
   }
   const parsed = parseArtifactPath(pos);
   const serverUrl = resolveServerUrl();
-  const { server } = await connectAndGetArtifactManager();
+  const { server, am } = await connectAndGetArtifactManager();
   const workspace = parsed.workspace || server.config.workspace;
+  const artifactId = resolveArtifactId(parsed, server.config.workspace);
   try {
+    if (!parsed.filePath) {
+      let info;
+      try {
+        info = await am.read({ artifact_id: artifactId, _rkwargs: true });
+      } catch (err) {
+        const msg = String(err?.message || err);
+        if (/not found|does not exist/i.test(msg)) {
+          console.error(`Artifact not found: ${pos}`);
+          process.exit(1);
+        }
+        throw err;
+      }
+      if (info?.type === "collection") {
+        const children = await am.list({ parent_id: artifactId, _rkwargs: true });
+        const list = Array.isArray(children) ? children : children?.items || [];
+        if (json) {
+          console.log(formatJson(list));
+          return;
+        }
+        if (list.length === 0) {
+          console.log("No child artifacts in this collection.");
+          return;
+        }
+        if (long) {
+          const rows = [["ALIAS", "TYPE", "MODIFIED", "DESCRIPTION"]];
+          for (const art of list) {
+            const manifest = art.manifest || {};
+            rows.push([
+              art.alias || art.id || "",
+              art.type || "",
+              art.last_modified ? new Date(art.last_modified * 1e3).toISOString().slice(0, 10) : "",
+              (manifest.description || "").slice(0, 50)
+            ]);
+          }
+          console.log(formatTable(rows));
+        } else {
+          for (const art of list) {
+            console.log(art.alias || art.id || "");
+          }
+        }
+        return;
+      }
+    }
     const url = buildFileUrl(serverUrl, workspace, parsed.alias, parsed.filePath);
     const resp = await fetchWithAuth(url);
     if (!resp.ok) {
@@ -388,14 +523,19 @@ Examples:
           console.error("Source is a directory. Use -r to copy directories.");
           process.exit(1);
         }
-        const count = await uploadDirectory(am, artifactId, src, parsed.filePath || "", onProgress);
+        const dirLabel = `${basename(src)}/`;
+        const count = await uploadDirectory(
+          am,
+          artifactId,
+          src,
+          parsed.filePath || "",
+          makeBatchProgressCallback(dirLabel)
+        );
         if (autoCommit) {
           await am.commit({ artifact_id: artifactId, _rkwargs: true });
-          console.log(`
-Uploaded ${count} files and committed.`);
+          console.log(`Uploaded ${count} files and committed.`);
         } else {
-          console.log(`
-Uploaded ${count} files. Run \`hypha artifacts commit ${parsed.alias}\` to finalize.`);
+          console.log(`Uploaded ${count} files. Run \`hypha artifacts commit ${parsed.alias}\` to finalize.`);
         }
       } else {
         const remotePath = parsed.filePath || basename(src);
@@ -516,7 +656,6 @@ Alias: hypha artifacts mkdir`);
     };
     if (parent) createOpts.parent_id = parent;
     const result = await am.create(createOpts);
-    await am.commit({ artifact_id: result.id || pos, _rkwargs: true });
     if (json) {
       console.log(formatJson(result));
     } else {
@@ -727,6 +866,56 @@ Usage: hypha artifacts discard <artifact>`);
     await server.disconnect();
   }
 }
+async function artifactsServe(args) {
+  if (hasFlag(args, "--help", "-h")) {
+    console.log(`hypha artifacts serve \u2014 enable or disable static site hosting
+
+Usage: hypha artifacts serve <artifact> [options]
+
+Options:
+  --root <dir>       Root directory to serve (default: /)
+  --disable          Disable static site hosting
+
+Examples:
+  hypha art serve my-site                  # Enable \u2014 serve from artifact root
+  hypha art serve my-site --root dist      # Serve from /dist subdirectory
+  hypha art serve my-site --disable        # Disable static site hosting`);
+    return;
+  }
+  const pos = positionalArgs(args, ["--root"])[0];
+  if (!pos) {
+    console.error("Usage: hypha artifacts serve <artifact> [--root <dir>] [--disable]");
+    process.exit(1);
+  }
+  const disable = hasFlag(args, "--disable");
+  const root = getFlag(args, "--root") || "/";
+  const parsed = parseArtifactPath(pos);
+  const { server, am } = await connectAndGetArtifactManager();
+  const artifactId = resolveArtifactId(parsed, server.config.workspace);
+  const serverUrl = resolveServerUrl();
+  const workspace = parsed.workspace || server.config.workspace;
+  try {
+    const config = {
+      view_config: disable ? "disabled" : { root_directory: root }
+    };
+    await am.edit({
+      artifact_id: artifactId,
+      config,
+      _rkwargs: true
+    });
+    if (disable) {
+      console.log(`Static site hosting disabled: ${parsed.alias}`);
+    } else {
+      const url = `${serverUrl}/${workspace}/view/${parsed.alias}`;
+      console.log(`Static site enabled: ${url}`);
+      if (root && root !== "/") {
+        console.log(`  Serving from: ${root}`);
+      }
+    }
+  } finally {
+    await server.disconnect();
+  }
+}
 async function handleArtifactsCommand(args) {
   const sub = args[0];
   const commandArgs = args.slice(1);
@@ -754,6 +943,8 @@ async function handleArtifactsCommand(args) {
     await artifactsEdit(commandArgs);
   } else if (sub === "discard") {
     await artifactsDiscard(commandArgs);
+  } else if (sub === "serve") {
+    await artifactsServe(commandArgs);
   } else {
     console.error(`Unknown artifacts command: ${sub}`);
     printArtifactsHelp();

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-BvfSCkvr.mjs → helpers-BC4AKy6a.mjs}

@@ -62,15 +62,33 @@ async function connectToHypha(opts) {
   const token = resolveToken(opts);
   const workspace = resolveWorkspace(opts);
   if (!token) {
-    console.error("No token found. Run `hypha login` first, or set HYPHA_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');
-  const server = await hyphaWebsocketClient.connectToServer({
-    server_url: serverUrl,
-    token,
-    workspace: workspace || void 0
-  });
+  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) {
@@ -78,7 +96,8 @@ async function loginToHypha(serverUrl) {
   const { hyphaWebsocketClient } = await import('hypha-rpc');
   console.log(`Logging in to ${url}...`);
   const token = await hyphaWebsocketClient.login({
-    server_url: url
+    server_url: url,
+    logger: null
   });
   if (!token) {
     console.error("Login failed \u2014 no token received.");
@@ -86,7 +105,8 @@ async function loginToHypha(serverUrl) {
   }
   const server = await hyphaWebsocketClient.connectToServer({
     server_url: url,
-    token
+    token,
+    logger: null
   });
   const ws = server.config.workspace;
   writeEnvValue("HYPHA_SERVER_URL", url);
@@ -184,5 +204,21 @@ function printProgress(label, 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, printProgress as m, positionalArgs as p, resolveServerUrl as r };
+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-XO_tEtii.mjs → workspace-DE2jBAXs.mjs}

@@ -1,4 +1,4 @@
-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-DWQC3Lr8.mjs';
+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';
@@ -120,7 +120,9 @@ Options:
     console.log(`${clients.length} client(s) in workspace ${targetWs}`);
     if (clients.length === 0) return;
     for (const c of clients.slice(0, 50)) {
-      console.log(`  ${c}`);
+      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`);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "hypha-cli",
-    "version": "0.1.10",
+    "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"
     },