@vatio-ai/cli 0.37.2

package/lib/support.mjs

@@ -0,0 +1,106 @@
+// Terminal plumbing shared by every command: how the CLI stops, and how it
+// reads the flags that mean the same thing everywhere.
+
+import { execFileSync } from "node:child_process";
+
+export class UserError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "UserError";
+  }
+}
+
+// The Ruby CLI's `abort`: a sentence on stderr and exit 1. Thrown rather than
+// exiting on the spot so one place at the top decides how a failure prints.
+export function fail(message) {
+  throw new UserError(message);
+}
+
+// `--env NAME` is the one way to say which deployment a command is about:
+// live, preview, or a named preview like pr-42.
+//
+// The default is the command's own and is passed in, because the sensible
+// answer differs: push writes a preview, pull brings down whatever is actually
+// running. `--as` was the spelling on push and publish and stays as an alias --
+// it is sitting in CI jobs, and there is nothing wrong with what it does.
+export function takeEnv(args, { fallback = null } = {}) {
+  let environment = fallback;
+  const rest = [];
+
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    const match = /^--(env|as)(?:=(.*))?$/.exec(arg);
+    if (!match) {
+      rest.push(arg);
+      continue;
+    }
+    if (match[2] !== undefined) {
+      environment = match[2];
+      continue;
+    }
+    i += 1;
+    if (i >= args.length) fail(`${match[0]} needs a deployment name (live, preview, or a preview name)`);
+    environment = args[i];
+  }
+
+  args.length = 0;
+  args.push(...rest);
+  return environment;
+}
+
+export function takeFlag(args, name) {
+  const index = args.indexOf(name);
+  if (index === -1) return false;
+  args.splice(index, 1);
+  return true;
+}
+
+export function takeValue(args, name) {
+  for (let i = 0; i < args.length; i += 1) {
+    if (args[i] === name) {
+      const value = args[i + 1];
+      if (value === undefined) fail(`${name} needs a value`);
+      args.splice(i, 2);
+      return value;
+    }
+    const prefix = `${name}=`;
+    if (args[i].startsWith(prefix)) {
+      const value = args[i].slice(prefix.length);
+      args.splice(i, 1);
+      return value;
+    }
+  }
+  return null;
+}
+
+// Stamped on a deployment so a revision can be traced back to a commit. Absent
+// outside a repository, which is fine -- a workspace does not have to be in one.
+export function detectGitSha(cwd) {
+  try {
+    return execFileSync("git", ["rev-parse", "HEAD"], {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+export function openBrowser(url) {
+  if (!url) return;
+  const command =
+    process.platform === "darwin" ? ["open", [url]]
+    : process.platform === "win32" ? ["cmd", ["/c", "start", "", url]]
+    : ["xdg-open", [url]];
+  try {
+    execFileSync(command[0], command[1], { stdio: "ignore" });
+  } catch {
+    // A headless machine has no browser to open, and the URL is already
+    // printed above this call. Nothing to report.
+  }
+}
+
+export function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/lib/version.mjs

@@ -0,0 +1,11 @@
+// Read from package.json rather than written twice: `npx vatio` resolves a
+// version from the registry, and a constant in here could disagree with the
+// one the developer actually downloaded.
+
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+
+const here = dirname(fileURLToPath(import.meta.url));
+
+export const VERSION = JSON.parse(readFileSync(join(here, "..", "package.json"), "utf8")).version;

package/lib/workspace.mjs

@@ -0,0 +1,75 @@
+// Where the workspace is, and which remote it deploys to. Addressing, not
+// contract -- the port of cli/lib/workspace_root.rb, and deliberately just as
+// small.
+//
+// What a `tools/*.js` declares, which blocks `vatio.yml` accepts and whether
+// any of it is valid are answered by POST /api/v1/:slug/deploy/check. The one
+// thing a client cannot ask the platform for is the address of that call: the
+// slug is in its URL. So this reads `workspace:` and stops.
+
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { dirname, join, parse as parsePath, resolve } from "node:path";
+import { parse as parseYaml } from "yaml";
+
+export const MANIFEST_FILE = "vatio.yml";
+// Keep in sync with Workspace::SLUG_FORMAT in urcalab/vatio. A slug that gets
+// past this is still the platform's to reject; matching here only turns a typo
+// into a sentence instead of a 404.
+export const SLUG_FORMAT = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+// A workspace has exactly one agent and it is the conversation entry point.
+export const ENTRY_AGENT = "main";
+
+// The manifest in a directory, or null when the directory is not a workspace
+// root. This file is the only thing that makes one.
+export function manifestPath(dir) {
+  const candidate = join(dir, MANIFEST_FILE);
+  try {
+    return statSync(candidate).isFile() ? candidate : null;
+  } catch {
+    return null;
+  }
+}
+
+// Any directory holding a manifest is a workspace root, so a vatio.yml can sit
+// anywhere -- beside a backend, in a monorepo's agents/ folder, at the top of
+// its own repo. The nearest one wins.
+export function findWorkspaceRoot(startDir) {
+  let current = resolve(startDir);
+  for (;;) {
+    if (manifestPath(current)) return current;
+    const parent = dirname(current);
+    if (parent === current || parent === parsePath(current).root) {
+      return manifestPath(parent) ? parent : null;
+    }
+    current = parent;
+  }
+}
+
+// Which workspace this directory deploys to. Addressing, not content: it names
+// the remote, so it never rides along in the deployed manifest. Null when the
+// file does not declare one.
+export function workspaceSlug(dir) {
+  const file = manifestPath(dir);
+  if (!file) return null;
+
+  const main = readManifest(file);
+  if (!main || typeof main !== "object" || Array.isArray(main)) return null;
+
+  const slug = String(main.workspace ?? "").trim().toLowerCase();
+  if (slug === "") return null;
+  if (!SLUG_FORMAT.test(slug)) {
+    throw new Error(
+      `${MANIFEST_FILE}: workspace "${slug}" is not a slug (lowercase letters, numbers, hyphens)`
+    );
+  }
+  return slug;
+}
+
+function readManifest(file) {
+  if (!existsSync(file)) return null;
+  try {
+    return parseYaml(readFileSync(file, "utf8"));
+  } catch (error) {
+    throw new Error(`${MANIFEST_FILE}: ${error.message}`);
+  }
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@vatio-ai/cli",
+  "version": "0.37.2",
+  "description": "Vatio CLI — deploy and manage Vatio agent workspaces",
+  "keywords": ["vatio", "agent", "ai", "cli", "deploy"],
+  "homepage": "https://vatio.ai",
+  "bugs": "https://vatio.ai/docs",
+  "license": "SEE LICENSE IN LICENSE.txt",
+  "author": "Vatio",
+  "type": "module",
+  "bin": {
+    "vatio": "bin/vatio.mjs"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "files": [
+    "bin",
+    "lib",
+    "README.md",
+    "LICENSE.txt"
+  ],
+  "dependencies": {
+    "yaml": "^2.5.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/urcalab/vatio.git",
+    "directory": "cli"
+  }
+}