@kryd/cli 0.1.0 → 0.2.0

package/README.md

@@ -10,15 +10,15 @@ npm install -g @kryd/cli      # then use the `kryd` command
 npx @kryd/cli <command>
 ```
 
-Requires Node.js ≥ 22.
+Requires Node.js ≥ 22 and git (the CLI shells out to git for `kryd init` and `kryd push`).
 
 ## Quickstart
 
 ```sh
 kryd login                    # sign in via the browser
 kryd init                     # link this folder to a Kryd project (+ a `kryd` git remote)
-git push kryd main            # build → deploy → live, with a streamed log
-kryd logs                     # follow the linked project's latest deploy
+kryd push                     # push the current branch → build → deploy → live, streamed
+kryd logs                     # follow the linked project's latest deploy (kryd push already does)
 kryd logs <project> --runtime # tail the live app's stdout/stderr
 ```
 
@@ -30,7 +30,8 @@ Once you've run `kryd init` in a directory, the commands below work **arg-less**
 |---|---|
 | `kryd login` / `logout` / `whoami` | Authenticate the CLI (browser flow); the token is stored in `~/.kryd`. |
 | `kryd init` | Link the current repo to a Kryd project + register the deploy webhook + add a `kryd` git remote. |
-| `kryd deploy [project]` | Trigger a deploy of the production branch and follow it live. |
+| `kryd push [branch]` | Push to the `kryd` remote and follow the deploy it triggers (defaults to the current branch). |
+| `kryd deploy [project]` | Re-deploy the production-branch HEAD already on the forge — no new commit. |
 | `kryd logs [target]` | Follow a deploy's build/deploy log (`--runtime` tails the live container instead). |
 | `kryd rollback [project] [deployment]` | Roll back to a previous successful deploy — no rebuild. |
 | `kryd db create \| detach [project]` | Attach / tear down managed Postgres (shared or bring-your-own). |

package/dist/index.js

@@ -15144,6 +15144,32 @@ async function listDeployments(apiUrl, token, projectId) {
   }
   return (await res.json()).items;
 }
+function findDeploymentsForCommit(deployments, commitSha, branch) {
+  return deployments.filter((d) => d.commitSha === commitSha && d.branch === branch);
+}
+async function pollForNewDeployment(fetchDeployments, match, opts) {
+  const intervalMs = opts?.intervalMs ?? 2e3;
+  const timeoutMs = opts?.timeoutMs ?? 6e4;
+  const maxConsecutiveErrors = opts?.maxConsecutiveErrors ?? 5;
+  const sleep = opts?.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  const started = Date.now();
+  let consecutiveErrors = 0;
+  for (; ; ) {
+    try {
+      const items = await fetchDeployments();
+      consecutiveErrors = 0;
+      const fresh = findDeploymentsForCommit(items, match.commitSha, match.branch).filter(
+        (d) => !match.knownIds.has(d.id)
+      );
+      const found = fresh[fresh.length - 1];
+      if (found) return found;
+    } catch (err) {
+      if (++consecutiveErrors > maxConsecutiveErrors) throw err;
+    }
+    if (Date.now() - started >= timeoutMs) return null;
+    await sleep(intervalMs);
+  }
+}
 function dataFromFrame(frame) {
   const data = frame.split("\n").filter((l) => l.startsWith("data:")).map((l) => l.slice(5).replace(/^ /, "")).join("\n");
   return data.length > 0 ? data : void 0;
@@ -15301,7 +15327,7 @@ function inspectProject(cwd) {
 }
 
 // src/git.ts
-import { execFileSync } from "node:child_process";
+import { execFileSync, spawnSync } from "node:child_process";
 function authenticatedRemoteUrl(cloneUrl, username, token) {
   const prefix = "https://";
   if (!cloneUrl.startsWith(prefix)) return cloneUrl;
@@ -15330,6 +15356,43 @@ function configureGitRemote(cwd, remote, url2) {
     return { status: "unavailable" };
   }
 }
+function probe(cwd, args) {
+  try {
+    const value = execFileSync("git", args, {
+      cwd,
+      stdio: ["ignore", "pipe", "ignore"]
+    }).toString().trim();
+    return { status: "ok", value };
+  } catch (err) {
+    if (err.code === "ENOENT") return { status: "no-git" };
+    return { status: "failed" };
+  }
+}
+function gitAvailable(cwd) {
+  const res = probe(cwd, ["rev-parse", "--is-inside-work-tree"]);
+  if (res.status === "no-git") return res;
+  if (res.status !== "ok" || res.value !== "true") return { status: "not-a-repo" };
+  return { status: "ok" };
+}
+function currentBranch(cwd) {
+  return probe(cwd, ["rev-parse", "--abbrev-ref", "HEAD"]);
+}
+function headSha(cwd, ref) {
+  return probe(cwd, ["rev-parse", ref]);
+}
+function hasRemote(cwd, remote) {
+  const res = probe(cwd, ["remote"]);
+  if (res.status !== "ok") return res;
+  return { status: "ok", value: res.value.split(/\s+/).filter(Boolean).includes(remote) };
+}
+function pushBranch(cwd, remote, branch, extraArgs) {
+  const res = spawnSync("git", ["push", remote, branch, ...extraArgs], {
+    cwd,
+    stdio: "inherit"
+  });
+  if (res.status === 0) return { status: "ok" };
+  return { status: "failed", code: res.status ?? 1 };
+}
 
 // src/index.ts
 function reportError(err) {
@@ -15458,20 +15521,22 @@ async function runInit(opts) {
       case "added":
       case "updated":
         nextStep = `${remote.status === "added" ? "Added" : "Updated"} git remote "${remote.remote}" (with your push credential).
-Next: git push ${remote.remote} ${branch}   # push to deploy
+Next: kryd push   # push to deploy (same as \`git push ${remote.remote} ${branch}\`)
 `;
         break;
       case "not-a-repo":
         nextStep = `No git repo here yet. To deploy (the URL carries your push token \u2014 keep it private):
   git init && git add -A && git commit -m "init"
   git remote add kryd ${authedUrl}
-  git push kryd ${branch}
+  kryd push
 `;
         break;
       case "unavailable":
-        nextStep = `Add the remote, then push to deploy (the URL carries your push token \u2014 keep it private):
+        nextStep = gitAvailable(cwd).status === "no-git" ? `git is not installed, so the deploy remote could not be configured.
+Install git (https://git-scm.com/downloads), then re-run \`kryd init\` here.
+` : `Add the remote, then push to deploy (the URL carries your push token \u2014 keep it private):
   git remote add kryd ${authedUrl}
-  git push kryd ${branch}
+  kryd push
 `;
         break;
     }
@@ -15605,6 +15670,135 @@ async function runDeploy(opts) {
     reportError(err);
   }
 }
+async function runPush(opts) {
+  const apiUrl = resolveApiUrl(opts.apiUrl);
+  const token = loadConfig().token;
+  if (!token) {
+    process.stderr.write("Not logged in \u2014 run `kryd login` first.\n");
+    process.exitCode = 1;
+    return;
+  }
+  const cwd = opts.cwd ?? process.cwd();
+  const available = gitAvailable(cwd);
+  if (available.status === "no-git") {
+    process.stderr.write(
+      "git is not installed, and `kryd push` needs it to deploy.\nInstall git (https://git-scm.com/downloads), then try again.\n"
+    );
+    process.exitCode = 1;
+    return;
+  }
+  if (available.status !== "ok") {
+    process.stderr.write(
+      "Not a git repository \u2014 run `kryd push` from the root of your app's repo.\n"
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const remote = hasRemote(cwd, "kryd");
+  if (remote.status !== "ok" || !remote.value) {
+    process.stderr.write(
+      'No "kryd" git remote here. Run `kryd init` to link this project and configure it.\n'
+    );
+    process.exitCode = 1;
+    return;
+  }
+  if (opts.branch?.startsWith("-")) {
+    process.stderr.write(
+      `"${opts.branch}" is not a branch. Pass the branch before \`--\`, e.g. \`kryd push main -- ${opts.branch}\`.
+`
+    );
+    process.exitCode = 1;
+    return;
+  }
+  let branch = opts.branch;
+  if (!branch) {
+    const current = currentBranch(cwd);
+    if (current.status !== "ok") {
+      process.stderr.write("Could not determine the current branch \u2014 pass one, e.g. `kryd push main`.\n");
+      process.exitCode = 1;
+      return;
+    }
+    if (current.value === "HEAD") {
+      process.stderr.write(
+        "You are on a detached HEAD \u2014 pass the branch to push explicitly, e.g. `kryd push main`.\n"
+      );
+      process.exitCode = 1;
+      return;
+    }
+    branch = current.value;
+  }
+  const gitArgs = opts.gitArgs ?? [];
+  if (branch.includes(":") || branch.startsWith("+")) {
+    const pushed = pushBranch(cwd, "kryd", branch, gitArgs);
+    if (pushed.status === "failed") {
+      process.exitCode = pushed.code;
+      return;
+    }
+    process.stdout.write(
+      "Pushed. `kryd push` does not follow refspec pushes \u2014 use `kryd logs` to watch a deploy.\n"
+    );
+    return;
+  }
+  try {
+    const sha = headSha(cwd, branch);
+    if (sha.status !== "ok") {
+      process.stderr.write(`Unknown branch "${branch}" \u2014 nothing to push.
+`);
+      process.exitCode = 1;
+      return;
+    }
+    const commitSha = sha.value;
+    const projectId = resolveProjectId(void 0, opts.cwd);
+    if (!projectId) {
+      process.stderr.write("tip: run `kryd init` here to scope `kryd push` to this project.\n");
+    }
+    const fetchDeployments = () => listDeployments(apiUrl, token, projectId ?? void 0);
+    let known = null;
+    try {
+      known = findDeploymentsForCommit(await fetchDeployments(), commitSha, branch);
+    } catch {
+      known = null;
+    }
+    const pushed = pushBranch(cwd, "kryd", branch, gitArgs);
+    if (pushed.status === "failed") {
+      process.exitCode = pushed.code;
+      return;
+    }
+    if (known === null) {
+      process.stdout.write(
+        "Pushed. Could not reach the API to follow the deploy \u2014 try `kryd logs`.\n"
+      );
+      return;
+    }
+    process.stdout.write("Waiting for the deploy to start\u2026\n");
+    const deployment = await pollForNewDeployment(
+      fetchDeployments,
+      { commitSha, branch, knownIds: new Set(known.map((d) => d.id)) },
+      {
+        ...opts.sleep ? { sleep: opts.sleep } : {},
+        ...opts.pollTimeoutMs !== void 0 ? { timeoutMs: opts.pollTimeoutMs } : {}
+      }
+    );
+    if (!deployment) {
+      const previous = known[0];
+      if (previous) {
+        const outcome = previous.status === "live" ? "is already deployed" : `has already been deployed once (that deploy ended \`${previous.status}\`)`;
+        process.stdout.write(
+          `Nothing new to push \u2014 ${commitSha.slice(0, 7)} ${outcome} (\`kryd logs ${previous.id}\` to review it).
+`
+        );
+      } else {
+        process.stdout.write(
+          "Pushed, but no deploy has started yet. Follow it with `kryd logs`.\n" + (projectId ? "" : "If this keeps happening, re-run `kryd init` to link this folder.\n")
+        );
+      }
+      return;
+    }
+    await followDeploy(apiUrl, token, deployment.id);
+  } catch (err) {
+    reportError(err);
+  }
+}
 async function runRollback(opts) {
   const apiUrl = resolveApiUrl(opts.apiUrl);
   const token = loadConfig().token;
@@ -15811,7 +16005,7 @@ async function runAiEnable(opts) {
     const status = await enableAi(apiUrl, token, { projectId: project });
     process.stdout.write(
       `AI enabled for ${project}.
-` + (status.url ? `Endpoint: ${status.url}
+` + (status.url ? `Endpoint: ${status.url} (OpenAI-compatible base URL \u2014 use it as-is)
 ` : "") + `AI_GATEWAY_URL + AI_GATEWAY_TOKEN will be injected on your next deploy (kryd deploy).
 `
     );
@@ -15849,7 +16043,7 @@ async function runStorageDetach(opts) {
     reportError(err);
   }
 }
-var CLI_VERSION = true ? "0.1.0" : "0.0.0-dev";
+var CLI_VERSION = true ? "0.2.0" : "0.0.0-dev";
 var program = new Command();
 program.name("kryd").description("Kryd CLI").version(CLI_VERSION);
 program.command("login").description("Sign in via the browser (default) and store a token").option("--email <email>", "account email (with --password; non-interactive escape hatch)").option("--password <password>", "account password (with --email; visible in `ps` \u2014 prefer the browser flow)").option(
@@ -15876,6 +16070,11 @@ program.command("logs [target]").description(
 ).option("--api-url <url>", "control-plane API base URL").action(
   (target, opts) => opts.runtime ? runRuntimeLogs({ project: target, since: opts.since, apiUrl: opts.apiUrl }) : runLogs({ apiUrl: opts.apiUrl, deployment: target })
 );
+program.command("push [branch]").description(
+  "Push to the kryd remote and follow the deploy it triggers (defaults to the current branch)"
+).option("--api-url <url>", "control-plane API base URL").action(
+  (branch, opts, cmd) => runPush({ ...opts, branch, gitArgs: cmd.args.slice(1) })
+);
 program.command("deploy [project]").description("Trigger a deploy of the project's production branch and follow it live").option("--api-url <url>", "control-plane API base URL").action((project, opts) => runDeploy({ ...opts, project }));
 program.command("rollback [project] [deployment]").description("Roll back to a previous successful deploy (no rebuild) and follow it live").option("--api-url <url>", "control-plane API base URL").action(
   (project, deployment, opts) => runRollback({ ...opts, project, deployment })
@@ -15910,6 +16109,7 @@ export {
   runLogin,
   runLogout,
   runLogs,
+  runPush,
   runRollback,
   runRuntimeLogs,
   runStorageCreate,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kryd/cli",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Kryd CLI — push a React / Vite / Next.js app to the effortless EU-sovereign deploy stack on Scaleway: git push → live with SSL, one-click managed Postgres & object storage, and an EU-hosted AI gateway already wired in.",
   "keywords": [
     "kryd",
@@ -51,8 +51,8 @@
     "typescript": "^5.6.3",
     "vitest": "^2.1.8",
     "@kryd/shared-types": "0.0.0",
-    "@kryd/config-ts": "0.0.0",
-    "@kryd/config-eslint": "0.0.0"
+    "@kryd/config-eslint": "0.0.0",
+    "@kryd/config-ts": "0.0.0"
   },
   "scripts": {
     "build": "esbuild src/index.ts --bundle --platform=node --format=esm --external:commander --define:__KRYD_VERSION__=\\\"$npm_package_version\\\" --outfile=dist/index.js",