hypha-cli 0.1.7 → 0.1.9

package/dist/apps-D659xu7q.mjs

@@ -0,0 +1,424 @@
+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 'os';
+
+const IGNORED_DIRS = /* @__PURE__ */ new Set([
+  "__pycache__",
+  ".git",
+  ".venv",
+  ".idea",
+  ".pytest_cache",
+  ".mypy_cache",
+  "build",
+  "dist",
+  "__pypackages__",
+  "node_modules"
+]);
+const IGNORED_FILES = /* @__PURE__ */ new Set([
+  ".DS_Store",
+  ".gitignore",
+  ".gitattributes",
+  ".env"
+]);
+const IGNORED_SUFFIXES = [".pyc", ".pyo", ".swp", ".tmp", ".bak"];
+const TEXT_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".py",
+  ".js",
+  ".ts",
+  ".mjs",
+  ".cjs",
+  ".jsx",
+  ".tsx",
+  ".html",
+  ".htm",
+  ".css",
+  ".scss",
+  ".less",
+  ".json",
+  ".yaml",
+  ".yml",
+  ".toml",
+  ".ini",
+  ".cfg",
+  ".conf",
+  ".md",
+  ".txt",
+  ".rst",
+  ".csv",
+  ".tsv",
+  ".sh",
+  ".bash",
+  ".zsh",
+  ".fish",
+  ".xml",
+  ".svg",
+  ".sql",
+  ".r",
+  ".R",
+  ".jl",
+  ".c",
+  ".h",
+  ".cpp",
+  ".hpp",
+  ".java",
+  ".go",
+  ".rs",
+  ".dockerfile",
+  ".env.example"
+]);
+function isTextFile(name) {
+  const ext = extname(name).toLowerCase();
+  if (TEXT_EXTENSIONS.has(ext)) return true;
+  if (!ext && !name.startsWith(".")) return true;
+  return false;
+}
+function isIgnored(name, isDir) {
+  if (isDir) return IGNORED_DIRS.has(name);
+  if (IGNORED_FILES.has(name)) return true;
+  return IGNORED_SUFFIXES.some((s) => name.endsWith(s));
+}
+function collectFiles(dir, base = "") {
+  const entries = readdirSync(dir, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    if (isIgnored(entry.name, entry.isDirectory())) continue;
+    const fullPath = join(dir, entry.name);
+    const relPath = base ? `${base}/${entry.name}` : entry.name;
+    if (entry.isDirectory()) {
+      files.push(...collectFiles(fullPath, relPath));
+    } else {
+      if (isTextFile(entry.name)) {
+        files.push({ name: relPath, content: readFileSync(fullPath, "utf-8"), format: "text" });
+      } else {
+        files.push({ name: relPath, content: readFileSync(fullPath).toString("base64"), format: "base64" });
+      }
+    }
+  }
+  return files;
+}
+function parseInstallArgs(args) {
+  const source = positionalArgs(args, ["--id", "--manifest", "--files"])[0];
+  return {
+    source,
+    id: getFlag(args, "--id"),
+    manifest: getFlag(args, "--manifest"),
+    files: getAllFlags(args, "--files"),
+    overwrite: hasFlag(args, "--overwrite")
+  };
+}
+function parseStartArgs(args) {
+  const pos = positionalArgs(args, ["--timeout"])[0];
+  return {
+    appId: pos,
+    timeout: getFlagInt(args, "--timeout"),
+    wait: hasFlag(args, "--wait")
+  };
+}
+function parseStopArgs(args) {
+  const pos = positionalArgs(args)[0];
+  return {
+    id: pos,
+    all: hasFlag(args, "--all")
+  };
+}
+function parseLogsArgs(args) {
+  const pos = positionalArgs(args, ["--tail", "--type"])[0];
+  return {
+    instanceId: pos,
+    tail: getFlagInt(args, "--tail"),
+    type: getFlag(args, "--type")
+  };
+}
+function printAppsHelp() {
+  console.log(`hypha apps \u2014 manage server apps
+
+Usage: hypha apps <command> [options]
+
+Commands:
+  list [--json]                        List installed app definitions
+  info <app-id> [--json]               Show app details
+  install <source> [options]           Install an app definition
+  uninstall <app-id>                   Remove an app definition
+  start <app-id> [options]             Start an app instance
+  stop <id> [--all]                    Stop instance(s)
+  ps [--json]                          List running instances
+  logs <instance-id> [options]         View instance logs
+
+Install options:
+  --id <app-id>                        Custom app ID (default: derived from source)
+  --manifest <path>                    Manifest file (JSON/YAML)
+  --files <dir>                        Additional file directory (repeatable)
+  --overwrite                          Overwrite existing app
+
+Start options:
+  --timeout <seconds>                  Start timeout (default: 60)
+  --wait                               Wait for service to be ready
+
+Logs options:
+  --tail <n>                           Show last N log entries
+  --type <stdout|stderr>               Filter by log type`);
+}
+async function getServerApps() {
+  const server = await connectToHypha();
+  const serverApps = await server.getService("server-apps");
+  return [server, serverApps];
+}
+async function appsList(args) {
+  const json = hasFlag(args, "--json");
+  const [server, serverApps] = await getServerApps();
+  try {
+    const apps = await serverApps.list_apps({ _rkwargs: true });
+    if (json) {
+      console.log(formatJson(apps));
+      return;
+    }
+    if (!apps || apps.length === 0) {
+      console.log("No installed apps.");
+      return;
+    }
+    const rows = [["APP ID", "NAME", "TYPE"]];
+    for (const app of apps) {
+      const manifest = app.manifest || {};
+      rows.push([
+        app.id || app.alias || "",
+        manifest.name || "",
+        manifest.type || app.type || ""
+      ]);
+    }
+    console.log(formatTable(rows));
+  } finally {
+    await server.disconnect();
+  }
+}
+async function appsInfo(args) {
+  const pos = positionalArgs(args)[0];
+  const json = hasFlag(args, "--json");
+  if (!pos) {
+    console.error("Usage: hypha apps info <app-id>");
+    process.exit(1);
+  }
+  const [server, serverApps] = await getServerApps();
+  try {
+    const info = await serverApps.get_app_info({
+      app_id: pos,
+      _rkwargs: true
+    });
+    if (json) {
+      console.log(formatJson(info));
+    } else {
+      const manifest = info.manifest || {};
+      console.log(`App ID:      ${info.id || info.alias || pos}`);
+      console.log(`Name:        ${manifest.name || "N/A"}`);
+      console.log(`Type:        ${manifest.type || info.type || "N/A"}`);
+      console.log(`Description: ${manifest.description || "N/A"}`);
+      if (info.versions?.length) {
+        console.log(`Versions:    ${info.versions.map((v) => v.name || v).join(", ")}`);
+      }
+    }
+  } finally {
+    await server.disconnect();
+  }
+}
+async function appsInstall(args) {
+  const parsed = parseInstallArgs(args);
+  if (!parsed.source) {
+    console.error("Usage: hypha apps install <source> [--id <app-id>] [--manifest <path>] [--files <dir>...] [--overwrite]");
+    process.exit(1);
+  }
+  const [server, serverApps] = await getServerApps();
+  try {
+    const installOpts = {
+      _rkwargs: true,
+      overwrite: parsed.overwrite
+    };
+    if (parsed.id) {
+      installOpts.app_id = parsed.id;
+    }
+    if (parsed.source.startsWith("http://") || parsed.source.startsWith("https://")) {
+      installOpts.source = parsed.source;
+    } else {
+      const stat = statSync(parsed.source);
+      if (stat.isFile()) {
+        installOpts.source = readFileSync(parsed.source, "utf-8");
+      } else if (stat.isDirectory()) {
+        installOpts.files = collectFiles(parsed.source);
+      }
+    }
+    if (parsed.manifest) {
+      const manifestContent = readFileSync(parsed.manifest, "utf-8");
+      installOpts.manifest = JSON.parse(manifestContent);
+    }
+    if (parsed.files.length > 0) {
+      const existing = installOpts.files || [];
+      for (const fileDir of parsed.files) {
+        existing.push(...collectFiles(fileDir));
+      }
+      installOpts.files = existing;
+    }
+    const appId = await serverApps.install(installOpts);
+    console.log(`Installed: ${appId}`);
+  } finally {
+    await server.disconnect();
+  }
+}
+async function appsUninstall(args) {
+  const appId = positionalArgs(args)[0];
+  if (!appId) {
+    console.error("Usage: hypha apps uninstall <app-id>");
+    process.exit(1);
+  }
+  const [server, serverApps] = await getServerApps();
+  try {
+    const artifactManager = await server.getService("artifact-manager");
+    await artifactManager.delete({
+      artifact_id: appId,
+      _rkwargs: true
+    });
+    console.log(`Uninstalled: ${appId}`);
+  } finally {
+    await server.disconnect();
+  }
+}
+async function appsStart(args) {
+  const parsed = parseStartArgs(args);
+  if (!parsed.appId) {
+    console.error("Usage: hypha apps start <app-id> [--timeout N] [--wait]");
+    process.exit(1);
+  }
+  const [server, serverApps] = await getServerApps();
+  try {
+    const startOpts = {
+      app_id: parsed.appId,
+      _rkwargs: true
+    };
+    if (parsed.timeout) startOpts.timeout = parsed.timeout;
+    if (parsed.wait) startOpts.wait_for_service = "default";
+    console.log(`Starting ${parsed.appId}...`);
+    const session = await serverApps.start(startOpts);
+    console.log(`Instance started:`);
+    console.log(`  ID:     ${session.id}`);
+    if (session.app_id) console.log(`  App:    ${session.app_id}`);
+    if (session.workspace) console.log(`  WS:     ${session.workspace}`);
+  } finally {
+    await server.disconnect();
+  }
+}
+async function appsStop(args) {
+  const parsed = parseStopArgs(args);
+  if (!parsed.id) {
+    console.error("Usage: hypha apps stop <id> [--all]");
+    console.error("  <id> can be an instance ID or app ID (with --all).");
+    process.exit(1);
+  }
+  const [server, serverApps] = await getServerApps();
+  try {
+    if (parsed.all) {
+      const running = await serverApps.list_running({ _rkwargs: true });
+      const matching = running.filter((s) => s.app_id === parsed.id);
+      if (matching.length === 0) {
+        console.log(`No running instances found for app: ${parsed.id}`);
+        return;
+      }
+      for (const instance of matching) {
+        try {
+          await serverApps.stop({ session_id: instance.id, _rkwargs: true });
+          console.log(`Stopped: ${instance.id}`);
+        } catch (err) {
+          console.error(`Failed to stop ${instance.id}: ${err.message}`);
+        }
+      }
+      console.log(`Stopped ${matching.length} instance(s) of ${parsed.id}.`);
+    } else {
+      await serverApps.stop({ session_id: parsed.id, _rkwargs: true });
+      console.log(`Stopped: ${parsed.id}`);
+    }
+  } finally {
+    await server.disconnect();
+  }
+}
+async function appsPs(args) {
+  const json = hasFlag(args, "--json");
+  const [server, serverApps] = await getServerApps();
+  try {
+    const running = await serverApps.list_running({ _rkwargs: true });
+    if (json) {
+      console.log(formatJson(running));
+      return;
+    }
+    if (!running || running.length === 0) {
+      console.log("No running instances.");
+      return;
+    }
+    const rows = [["INSTANCE ID", "APP ID", "STATUS", "CREATED"]];
+    for (const inst of running) {
+      rows.push([
+        inst.id || "",
+        inst.app_id || "",
+        inst.status || "running",
+        inst.created_at ? relativeTime(inst.created_at * 1e3) : ""
+      ]);
+    }
+    console.log(formatTable(rows));
+  } finally {
+    await server.disconnect();
+  }
+}
+async function appsLogs(args) {
+  const parsed = parseLogsArgs(args);
+  if (!parsed.instanceId) {
+    console.error("Usage: hypha apps logs <instance-id> [--tail N] [--type stdout|stderr]");
+    process.exit(1);
+  }
+  const [server, serverApps] = await getServerApps();
+  try {
+    const logOpts = {
+      session_id: parsed.instanceId,
+      _rkwargs: true
+    };
+    if (parsed.type) logOpts.type = parsed.type;
+    if (parsed.tail) logOpts.limit = parsed.tail;
+    const logs = await serverApps.get_logs(logOpts);
+    if (!logs || !logs.items || logs.items.length === 0) {
+      console.log("No logs available.");
+      return;
+    }
+    for (const entry of logs.items) {
+      const prefix = entry.type === "stderr" ? "[stderr] " : "";
+      console.log(`${prefix}${entry.content}`);
+    }
+  } finally {
+    await server.disconnect();
+  }
+}
+async function handleAppsCommand(args) {
+  const sub = args[0];
+  const commandArgs = args.slice(1);
+  if (!sub || sub === "--help" || sub === "-h") {
+    printAppsHelp();
+    return;
+  }
+  if (sub === "list" || sub === "ls") {
+    await appsList(commandArgs);
+  } else if (sub === "info") {
+    await appsInfo(commandArgs);
+  } else if (sub === "install") {
+    await appsInstall(commandArgs);
+  } else if (sub === "uninstall" || sub === "rm") {
+    await appsUninstall(commandArgs);
+  } else if (sub === "start") {
+    await appsStart(commandArgs);
+  } else if (sub === "stop") {
+    await appsStop(commandArgs);
+  } else if (sub === "ps") {
+    await appsPs(commandArgs);
+  } else if (sub === "logs") {
+    await appsLogs(commandArgs);
+  } else {
+    console.error(`Unknown apps command: ${sub}`);
+    printAppsHelp();
+    process.exit(1);
+  }
+}
+
+export { handleAppsCommand, parseInstallArgs, parseLogsArgs, parseStartArgs, parseStopArgs };