@hyze-cloud/cli 0.1.0 → 0.2.0

package/README.md

@@ -36,12 +36,18 @@ sudo mv dist/hyze /usr/local/bin/hyze
 ```bash
 hyze login                        # paste a key created in the dashboard (Settings → Developer)
 hyze projects                     # what exists in this workspace
-hyze deploy . --name my-api --runtime bun --port 3000 --subdomain my-api.hyzecloud.app
-hyze status my-api                # is it up? unknown when the platform cannot see the container
-hyze deployments my-api           # build history: queue place, waiting reason, cause of death
-hyze logs my-api                  # container output; `hyze logs my-api <deploymentId>` for the build log
+hyze deploy . --name my-api --subdomain my-api.hyzecloud.app
+hyze link                         # bind this folder to the app
+hyze status                       # is it up? unknown when the platform cannot see the container
+hyze deployments                  # build history: queue place, waiting reason, cause of death
+hyze logs                         # container output; pass a <deploymentId> for the build log
 ```
 
+`--name` is the only required flag on a first deploy: the runtime, the port and
+the memory come from inspecting what you sent. Add `--subdomain` when the app
+should be reachable on a public URL — an app the detector reads as an HTTP server
+needs one, and refuses before uploading if you forget it.
+
 ## Commands
 
 | Command | Talks to | What it does |
@@ -49,6 +55,7 @@ hyze logs my-api                  # container output; `hyze logs my-api <deploym
 | `login [--key <key>] [--no-verify]` | `GET /apps/`, `GET /plans/current` | store an API key, after checking it against the API |
 | `logout` | — | remove the stored key of the active profile |
 | `projects [--query] [--page] [--limit]` | `GET /apps/` | list the workspace's projects |
+| `link [appId] [--print]` | `GET /apps/` | bind this directory to a project (`.hyzerc.json`) |
 | `deploy [path] [--name] [--app] [--repo] …` | `GET /platform/config`, `POST /apps/inspect-env`, `POST /apps/deploy`, `GET /apps/:appId/deployments/:id` | zip (or send a `.zip`), upload, follow the build |
 | `deployments [appId] [deploymentId]` | `GET /apps/:appId/deployments[/:id]` | build history, or one deployment with its stage timeline |
 | `logs [appId] [deploymentId]` | `GET /apps/:appId/logs`, `GET /apps/:appId/deployments/:id` | container output, or the persisted build log |
@@ -58,6 +65,10 @@ hyze logs my-api                  # container output; `hyze logs my-api <deploym
 to the directory, so inside a project `hyze status`, `hyze logs` and
 `hyze deploy .` need no arguments.
 
+> The argument is the project's **id**, not its name. Inside a bound directory
+> you never type either; outside one, `hyze projects` lists the ids and
+> `hyze link <appId>` binds the directory.
+
 ```json
 // .hyzerc.json — nearest ancestor wins
 { "appId": "app_abc123", "workspaceId": "org_abc", "apiUrl": "https://api.hyzecloud.com/api" }
@@ -414,14 +425,26 @@ created              status   deployment   queue                     waiting
 ## Deploy details
 
 Key flags: `--name`, `--app <appId>` (redeploy, defaults to the project in
-`.hyzerc.json`), `--runtime node|bun|python`, `--memory <mb>`, `--port`/`--subdomain`
-(must be passed together), `--env KEY=VALUE` (repeatable), `--env-file`,
+`.hyzerc.json`), `--runtime node|bun|python`, `--memory <mb>`, `--subdomain <host>`,
+`--port <n>`, `--env KEY=VALUE` (repeatable), `--env-file`,
 `--root-dir`, `--start-command`, `--install-command`, `--build-command`,
 `--app-type`, `--machine`, `--exclude`/`--include`/`--include-ignored`,
 `--no-wait`, and `--repo <owner/name> [--branch] [--auto-deploy]` for GitHub.
 
-When `--runtime` is omitted the CLI asks the API to inspect the upload and uses the
-detected runtime. With waiting enabled (default) it follows the deployment stage
+What you do not have to pass is what the platform can work out. Without
+`--runtime` the CLI asks the API to inspect the upload and uses the detected
+runtime. Without `--port` it uses the port that inspection found, so
+`--subdomain` alone publishes an HTTP app. Without `--memory` it asks for the
+memory the project needs, capped by what the plan can still hand out — and says
+so when the cap bites.
+
+**A redeploy keeps what you did not mention.** Inside a bound directory,
+`hyze deploy .` targets that app and leaves its public address, port and memory
+exactly as they were: a field absent from the request means "keep it", never
+"clear it". Pass the flag to change it (`--subdomain other.hyzecloud.app`,
+`--memory 512`).
+
+With waiting enabled (default) it follows the deployment stage
 timeline on stderr and prints the settled deployment on stdout; a failed deployment
 exits `1` with the API error and a pointer to `hyze logs <appId> <deploymentId>`.
 
@@ -570,6 +593,10 @@ browser and an action that failed — and `tui.e2e.test.ts` runs the real binary
 inside a PTY to check what the terminal ends up showing, including the lifecycle
 calls it really sent and the cursor being handed back on exit.
 
+## Changelog
+
+See [CHANGELOG.md](https://github.com/Hyze-Cloud/hyze-cloud/blob/main/apps/cli/CHANGELOG.md).
+
 ## License
 
 MIT

package/dist/index.js

@@ -3652,7 +3652,7 @@ function deployPayload(name, flags, runtime, options) {
     ...flags.appId ? { appId: flags.appId } : {},
     name,
     runtime,
-    memoryMB: flags.memoryMB,
+    ...flags.memoryMB !== undefined ? { memoryMB: flags.memoryMB } : {},
     ...typeof options.startCommand === "string" ? { startupCommand: options.startCommand } : {},
     ...typeof options.installCommand === "string" ? { installCommand: options.installCommand } : {},
     ...typeof options.buildCommand === "string" ? { buildCommand: options.buildCommand } : {},
@@ -3733,6 +3733,7 @@ function reportMorePages(output, data) {
 }
 
 // src/commands/deploy.ts
+var MIN_MEMORY_MB = 256;
 var RUNTIMES = { node: "node", bun: "bun", python: "python" };
 var APP_TYPES = {
   "web-service": "web-service",
@@ -3790,12 +3791,9 @@ function resolveAppType(value) {
   return appType;
 }
 function parseDeployFlags(options, boundAppId) {
-  const memoryMB = parseInteger(String(options.memory), "--memory", 1);
+  const memoryMB = options.memory === undefined ? undefined : parseInteger(String(options.memory), "--memory", 1);
   const exposePort = options.port === undefined ? undefined : parseInteger(String(options.port), "--port", 1, 65535);
   const subdomain = typeof options.subdomain === "string" ? options.subdomain : undefined;
-  if (exposePort === undefined !== (subdomain === undefined)) {
-    throw new UsageError("--port and --subdomain must be provided together");
-  }
   return {
     memoryMB,
     exposePort,
@@ -3806,6 +3804,47 @@ function parseDeployFlags(options, boundAppId) {
     repo: typeof options.repo === "string" ? options.repo : undefined
   };
 }
+function assertExposurePairing(exposePort, subdomain, detectedPort) {
+  if (exposePort === undefined === (subdomain === undefined))
+    return;
+  if (subdomain !== undefined) {
+    throw new UsageError("--subdomain needs a port, and none could be detected", {
+      hint: "Pass --port <n> — the port the app listens on."
+    });
+  }
+  if (detectedPort !== undefined) {
+    throw new UsageError(`This app serves HTTP on port ${detectedPort}, so it needs a public hostname`, {
+      hint: "Pass --subdomain <host>, for example my-app.hyzecloud.app — or --app-type bot if it is not a web app."
+    });
+  }
+  throw new UsageError("--port needs a public hostname", {
+    hint: "Pass --subdomain <host>, for example my-app.hyzecloud.app."
+  });
+}
+async function fetchAvailableMemory(client) {
+  try {
+    const plan = await client.get("/plans/current");
+    const available = plan.usage?.availableRAM;
+    return typeof available === "number" ? available : null;
+  } catch {
+    return null;
+  }
+}
+async function resolveDeployMemory(client, flags, detectedMemoryMB, output) {
+  if (flags.memoryMB !== undefined)
+    return flags.memoryMB;
+  if (flags.appId !== undefined)
+    return;
+  const wanted = detectedMemoryMB ?? MIN_MEMORY_MB;
+  const available = await fetchAvailableMemory(client);
+  if (available === null)
+    return wanted;
+  const capped = Math.max(MIN_MEMORY_MB, Math.min(wanted, available));
+  if (capped !== wanted) {
+    output.info(`memory: ${capped}MB — the plan has ${available}MB free (detected ${wanted}MB)`);
+  }
+  return capped;
+}
 async function resolveAppName(ctx, flags, options, fallbackName) {
   const explicit = typeof options.name === "string" ? options.name.trim() : "";
   if (explicit.length > 0)
@@ -3923,6 +3962,30 @@ async function reportDeploy(ctx, data, options, appName) {
     output.warn(cancelledLine(appName, status));
   }
 }
+function resolveDetectedRuntime(runtimeFlag, detected, output) {
+  if (runtimeFlag)
+    return runtimeFlag;
+  if (!detected?.runtime) {
+    throw new UsageError("Could not detect the runtime — pass --runtime node|bun|python", {
+      hint: `Detected files: ${detected?.detectedFiles.join(", ") || "none"}`
+    });
+  }
+  output.info(detectionLine(detected.runtime, detected.label, detected.confidence));
+  return detected.runtime;
+}
+async function resolveDeployInputs(ctx, options, flags, upload, rootDirectory) {
+  const { client, output } = ctx;
+  const runtimeFlag = resolveRuntime(options.runtime);
+  const wantsDetection = runtimeFlag === undefined || flags.exposePort === undefined;
+  const detected = wantsDetection ? await client.post("/apps/inspect-env", {
+    form: multipartBody(upload, rootDirectory)
+  }) : undefined;
+  const runtime = resolveDetectedRuntime(runtimeFlag, detected, output);
+  const exposePort = flags.exposePort ?? detected?.exposePort ?? undefined;
+  assertExposurePairing(exposePort, flags.subdomain, detected?.exposePort ?? undefined);
+  const memoryMB = await resolveDeployMemory(client, flags, detected?.memoryMB, output);
+  return { runtime, exposePort, memoryMB };
+}
 async function deployFromUpload(ctx, options, flags, pathArgument) {
   const { client, output } = ctx;
   const name = await resolveAppName(ctx, flags, options, undefined);
@@ -3930,22 +3993,10 @@ async function deployFromUpload(ctx, options, flags, pathArgument) {
   const limit = await fetchUploadLimit(client);
   const upload = buildUpload({ source, flags: options, limit, onInfo: (message) => output.info(message) });
   const rootDirectory = typeof options.rootDir === "string" ? { rootDirectory: options.rootDir } : {};
-  let runtime = resolveRuntime(options.runtime);
-  if (!runtime) {
-    const detected = await client.post("/apps/inspect-env", {
-      form: multipartBody(upload, rootDirectory)
-    });
-    if (!detected.runtime) {
-      throw new UsageError("Could not detect the runtime — pass --runtime node|bun|python", {
-        hint: `Detected files: ${detected.detectedFiles.join(", ") || "none"}`
-      });
-    }
-    runtime = detected.runtime;
-    output.info(detectionLine(runtime, detected.label, detected.confidence));
-  }
+  const { runtime, exposePort, memoryMB } = await resolveDeployInputs(ctx, options, flags, upload, rootDirectory);
   const data = await client.post("/apps/deploy", {
     form: multipartBody(upload, {
-      ...deployPayload(name, flags, runtime, options),
+      ...deployPayload(name, { ...flags, exposePort, memoryMB }, runtime, options),
       ...Object.keys(flags.env).length > 0 ? { envVars: JSON.stringify(flags.env) } : {},
       ...options.autoRestart === false ? { autoRestart: false } : {}
     })
@@ -3977,11 +4028,12 @@ async function deployFromRepository(ctx, options, flags) {
   if (!runtime) {
     throw new UsageError("--runtime is required for repository deploys", { hint: "Pass --runtime node|bun|python." });
   }
+  assertExposurePairing(flags.exposePort, flags.subdomain, undefined);
   const name = await resolveAppName(ctx, flags, options, repoName);
   const repository = await resolveRepository(ctx, owner, repoName, typeof options.branch === "string" ? options.branch : undefined);
   const data = await ctx.client.post("/apps/deploy-from-repo", {
     body: {
-      ...deployPayload(name, flags, runtime, options),
+      ...deployPayload(name, { ...flags, memoryMB: flags.memoryMB ?? 512 }, runtime, options),
       ...Object.keys(flags.env).length > 0 ? { envVars: flags.env } : {},
       ...options.autoDeploy === true ? { autoDeploy: true } : {},
       repository: { id: repository.id, owner, name: repoName, branch: repository.branch }
@@ -3990,7 +4042,7 @@ async function deployFromRepository(ctx, options, flags) {
   await reportDeploy(ctx, data, options, name);
 }
 function registerDeployCommands(program) {
-  program.command("deploy [path]").description("Deploy a directory, a ZIP or a GitHub repository (defaults to the current directory)").option("--zip <file>", "deploy a ZIP file instead of a directory").option("--repo <owner/name>", "deploy from a GitHub repository").option("--branch <branch>", "branch for --repo (defaults to the repository default branch)").option("--auto-deploy", "redeploy automatically on push (--repo only)").option("--name <name>", "app name (required for a new app)").option("--app <appId>", "redeploy an existing app (defaults to the project in .hyzerc.json)").option("--runtime <runtime>", "node | bun | python (detected from the project when omitted)").option("--memory <mb>", "memory in MB", "512").option("--port <n>", "public port (must be paired with --subdomain)").option("--subdomain <host>", "public hostname (must be paired with --port)").option("--env <pairs...>", "environment variables as KEY=VALUE (repeatable)").option("--env-file <file>", "read environment variables from a .env-style file").option("--root-dir <dir>", "build from a subdirectory of the project").option("--start-command <cmd>", "override the start command").option("--install-command <cmd>", "override the install command").option("--build-command <cmd>", "override the build command").option("--app-type <type>", "web-service | static-site | bot | generic").option("--machine <machineId>", "pin the app to a specific machine").option("--no-auto-restart", "never restart the app automatically after a crash").option("--exclude <patterns...>", "ignore extra file patterns when zipping").option("--include <patterns...>", "re-include patterns that an ignore rule excluded").option("--include-ignored", "upload ignored files too (never .git or node_modules)").option("--wait", "wait for the deployment to finish (default)").option("--no-wait", "return as soon as the deployment is queued").action(async (path, options, command) => {
+  program.command("deploy [path]").description("Deploy a directory, a ZIP or a GitHub repository (defaults to the current directory)").option("--zip <file>", "deploy a ZIP file instead of a directory").option("--repo <owner/name>", "deploy from a GitHub repository").option("--branch <branch>", "branch for --repo (defaults to the repository default branch)").option("--auto-deploy", "redeploy automatically on push (--repo only)").option("--name <name>", "app name (required for a new app)").option("--app <appId>", "redeploy an existing app (defaults to the project in .hyzerc.json)").option("--runtime <runtime>", "node | bun | python (detected from the project when omitted)").option("--memory <mb>", "memory in MB (default: what the app needs, capped by the plan)").option("--port <n>", "public port (default: the port the app is detected to serve on)").option("--subdomain <host>", "public hostname (required to expose the app)").option("--env <pairs...>", "environment variables as KEY=VALUE (repeatable)").option("--env-file <file>", "read environment variables from a .env-style file").option("--root-dir <dir>", "build from a subdirectory of the project").option("--start-command <cmd>", "override the start command").option("--install-command <cmd>", "override the install command").option("--build-command <cmd>", "override the build command").option("--app-type <type>", "web-service | static-site | bot | generic").option("--machine <machineId>", "pin the app to a specific machine").option("--no-auto-restart", "never restart the app automatically after a crash").option("--exclude <patterns...>", "ignore extra file patterns when zipping").option("--include <patterns...>", "re-include patterns that an ignore rule excluded").option("--include-ignored", "upload ignored files too (never .git or node_modules)").option("--wait", "wait for the deployment to finish (default)").option("--no-wait", "return as soon as the deployment is queued").action(async (path, options, command) => {
     const ctx = createContext(command);
     const flags = parseDeployFlags(options, typeof options.app === "string" ? options.app : ctx.settings.projectConfig.appId);
     if (flags.repo) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyze-cloud/cli",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Command-line interface for Hyze Cloud \u2014 deploy projects, follow builds and read logs.",
   "type": "module",
   "bin": {