@alva-ai/toolkit 0.1.0

package/dist/cli.js

@@ -0,0 +1,1469 @@
+#!/usr/bin/env node
+
+// src/error.ts
+var AlvaError = class extends Error {
+  code;
+  status;
+  constructor(code, message, status) {
+    super(message);
+    this.name = "AlvaError";
+    this.code = code;
+    this.status = status;
+  }
+};
+
+// src/resources/fs.ts
+var FsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  /** Returns `ArrayBuffer` for binary files, or parsed JSON for time-series virtual paths. */
+  async read(params) {
+    return this.client._request("GET", "/api/v1/fs/read", {
+      query: { path: params.path, offset: params.offset, size: params.size }
+    });
+  }
+  /** Write file using JSON body (Mode 2). For text content. */
+  async write(params) {
+    this.client._requireAuth();
+    return this.client._request("POST", "/api/v1/fs/write", {
+      body: {
+        path: params.path,
+        data: params.data,
+        mkdir_parents: params.mkdir_parents
+      }
+    });
+  }
+  /** Write file using raw body (Mode 1). Supports binary data. Path and options are query params. */
+  async rawWrite(params) {
+    this.client._requireAuth();
+    return this.client._request("POST", "/api/v1/fs/write", {
+      query: {
+        path: params.path,
+        mkdir_parents: params.mkdir_parents
+      },
+      rawBody: params.body
+    });
+  }
+  async stat(params) {
+    this.client._requireAuth();
+    return this.client._request("GET", "/api/v1/fs/stat", {
+      query: { path: params.path }
+    });
+  }
+  async readdir(params) {
+    this.client._requireAuth();
+    return this.client._request("GET", "/api/v1/fs/readdir", {
+      query: { path: params.path, recursive: params.recursive }
+    });
+  }
+  async mkdir(params) {
+    this.client._requireAuth();
+    await this.client._request("POST", "/api/v1/fs/mkdir", {
+      body: { path: params.path }
+    });
+  }
+  async remove(params) {
+    this.client._requireAuth();
+    await this.client._request("DELETE", "/api/v1/fs/remove", {
+      query: { path: params.path, recursive: params.recursive }
+    });
+  }
+  async rename(params) {
+    this.client._requireAuth();
+    await this.client._request("POST", "/api/v1/fs/rename", {
+      body: { old_path: params.old_path, new_path: params.new_path }
+    });
+  }
+  async copy(params) {
+    this.client._requireAuth();
+    await this.client._request("POST", "/api/v1/fs/copy", {
+      body: { src_path: params.src_path, dst_path: params.dst_path }
+    });
+  }
+  async symlink(params) {
+    this.client._requireAuth();
+    await this.client._request("POST", "/api/v1/fs/symlink", {
+      body: {
+        target_path: params.target_path,
+        link_path: params.link_path
+      }
+    });
+  }
+  async readlink(params) {
+    this.client._requireAuth();
+    return this.client._request("GET", "/api/v1/fs/readlink", {
+      query: { path: params.path }
+    });
+  }
+  async chmod(params) {
+    this.client._requireAuth();
+    await this.client._request("POST", "/api/v1/fs/chmod", {
+      body: { path: params.path, mode: params.mode }
+    });
+  }
+  async grant(params) {
+    this.client._requireAuth();
+    await this.client._request("POST", "/api/v1/fs/grant", {
+      body: {
+        path: params.path,
+        subject: params.subject,
+        permission: params.permission
+      }
+    });
+  }
+  async revoke(params) {
+    this.client._requireAuth();
+    await this.client._request("POST", "/api/v1/fs/revoke", {
+      body: {
+        path: params.path,
+        subject: params.subject,
+        permission: params.permission
+      }
+    });
+  }
+};
+
+// src/resources/run.ts
+var RunResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  async execute(params) {
+    this.client._requireAuth();
+    return this.client._request("POST", "/api/v1/run", {
+      body: {
+        code: params.code,
+        entry_path: params.entry_path,
+        working_dir: params.working_dir,
+        args: params.args
+      }
+    });
+  }
+};
+
+// src/resources/deploy.ts
+var DeployResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  async create(params) {
+    this.client._requireAuth();
+    return this.client._request("POST", "/api/v1/deploy/cronjob", {
+      body: {
+        name: params.name,
+        path: params.path,
+        cron_expression: params.cron_expression,
+        args: params.args,
+        push_notify: params.push_notify
+      }
+    });
+  }
+  async list(params) {
+    this.client._requireAuth();
+    return this.client._request("GET", "/api/v1/deploy/cronjobs", {
+      query: { limit: params?.limit, cursor: params?.cursor }
+    });
+  }
+  async get(params) {
+    this.client._requireAuth();
+    return this.client._request(
+      "GET",
+      `/api/v1/deploy/cronjob/${params.id}`
+    );
+  }
+  async update(params) {
+    this.client._requireAuth();
+    const { id, ...body } = params;
+    return this.client._request("PATCH", `/api/v1/deploy/cronjob/${id}`, {
+      body
+    });
+  }
+  async delete(params) {
+    this.client._requireAuth();
+    await this.client._request("DELETE", `/api/v1/deploy/cronjob/${params.id}`);
+  }
+  async pause(params) {
+    this.client._requireAuth();
+    await this.client._request(
+      "POST",
+      `/api/v1/deploy/cronjob/${params.id}/pause`
+    );
+  }
+  async resume(params) {
+    this.client._requireAuth();
+    await this.client._request(
+      "POST",
+      `/api/v1/deploy/cronjob/${params.id}/resume`
+    );
+  }
+};
+
+// src/resources/release.ts
+var ReleaseResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  async feed(params) {
+    this.client._requireAuth();
+    return this.client._request("POST", "/api/v1/release/feed", {
+      body: {
+        name: params.name,
+        version: params.version,
+        cronjob_id: params.cronjob_id,
+        view_json: params.view_json,
+        description: params.description
+      }
+    });
+  }
+  async playbookDraft(params) {
+    this.client._requireAuth();
+    return this.client._request("POST", "/api/v1/draft/playbook", {
+      body: {
+        name: params.name,
+        display_name: params.display_name,
+        description: params.description,
+        feeds: params.feeds,
+        trading_symbols: params.trading_symbols
+      }
+    });
+  }
+  async playbook(params) {
+    this.client._requireAuth();
+    return this.client._request("POST", "/api/v1/release/playbook", {
+      body: {
+        name: params.name,
+        version: params.version,
+        feeds: params.feeds,
+        changelog: params.changelog
+      }
+    });
+  }
+};
+
+// src/resources/secrets.ts
+var SecretsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  async create(params) {
+    this.client._requireAuth();
+    await this.client._request("POST", "/api/v1/secrets", {
+      body: { name: params.name, value: params.value }
+    });
+  }
+  async list() {
+    this.client._requireAuth();
+    return this.client._request("GET", "/api/v1/secrets");
+  }
+  async get(params) {
+    this.client._requireAuth();
+    const encoded = encodeURIComponent(params.name);
+    return this.client._request(
+      "GET",
+      `/api/v1/secrets/${encoded}`
+    );
+  }
+  async update(params) {
+    this.client._requireAuth();
+    const encoded = encodeURIComponent(params.name);
+    await this.client._request("PUT", `/api/v1/secrets/${encoded}`, {
+      body: { value: params.value }
+    });
+  }
+  async delete(params) {
+    this.client._requireAuth();
+    const encoded = encodeURIComponent(params.name);
+    await this.client._request("DELETE", `/api/v1/secrets/${encoded}`);
+  }
+};
+
+// src/resources/sdkDocs.ts
+var SdkDocsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  async doc(params) {
+    this.client._requireAuth();
+    return this.client._request("GET", "/api/v1/sdk/doc", {
+      query: { name: params.name }
+    });
+  }
+  async partitions() {
+    this.client._requireAuth();
+    return this.client._request(
+      "GET",
+      "/api/v1/sdk/partitions"
+    );
+  }
+  async partitionSummary(params) {
+    this.client._requireAuth();
+    const encoded = encodeURIComponent(params.partition);
+    return this.client._request(
+      "GET",
+      `/api/v1/sdk/partitions/${encoded}/summary`
+    );
+  }
+};
+
+// src/resources/comments.ts
+var CommentsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  async create(params) {
+    this.client._requireAuth();
+    return this.client._request("POST", "/api/v1/playbook/comment", {
+      body: {
+        username: params.username,
+        name: params.name,
+        content: params.content,
+        parent_id: params.parent_id
+      }
+    });
+  }
+  async pin(params) {
+    this.client._requireAuth();
+    return this.client._request("POST", "/api/v1/playbook/comment/pin", {
+      body: { comment_id: params.comment_id }
+    });
+  }
+  async unpin(params) {
+    this.client._requireAuth();
+    return this.client._request("POST", "/api/v1/playbook/comment/unpin", {
+      body: { comment_id: params.comment_id }
+    });
+  }
+};
+
+// src/resources/remix.ts
+var RemixResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  async save(params) {
+    this.client._requireAuth();
+    await this.client._request("POST", "/api/v1/remix", {
+      body: {
+        child: params.child,
+        parents: params.parents
+      }
+    });
+  }
+};
+
+// src/resources/screenshot.ts
+var ScreenshotResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  async capture(params) {
+    this.client._requireAuth();
+    return this.client._request("GET", "/api/v1/screenshot", {
+      query: {
+        url: params.url,
+        selector: params.selector,
+        xpath: params.xpath
+      }
+    });
+  }
+};
+
+// src/resources/user.ts
+var UserResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  async me() {
+    this.client._requireAuth();
+    return this.client._request("GET", "/api/v1/me");
+  }
+};
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://api-llm.prd.alva.ai";
+var AlvaClient = class {
+  baseUrl;
+  apiKey;
+  _fs;
+  _run;
+  _deploy;
+  _release;
+  _secrets;
+  _sdk;
+  _comments;
+  _remix;
+  _screenshot;
+  _user;
+  constructor(config) {
+    this.baseUrl = config.baseUrl ?? DEFAULT_BASE_URL;
+    this.apiKey = config.apiKey;
+  }
+  get fs() {
+    return this._fs ??= new FsResource(this);
+  }
+  get run() {
+    return this._run ??= new RunResource(this);
+  }
+  get deploy() {
+    return this._deploy ??= new DeployResource(this);
+  }
+  get release() {
+    return this._release ??= new ReleaseResource(this);
+  }
+  get secrets() {
+    return this._secrets ??= new SecretsResource(this);
+  }
+  get sdk() {
+    return this._sdk ??= new SdkDocsResource(this);
+  }
+  get comments() {
+    return this._comments ??= new CommentsResource(this);
+  }
+  get remix() {
+    return this._remix ??= new RemixResource(this);
+  }
+  get screenshot() {
+    return this._screenshot ??= new ScreenshotResource(this);
+  }
+  get user() {
+    return this._user ??= new UserResource(this);
+  }
+  _requireAuth() {
+    if (!this.apiKey) {
+      throw new AlvaError(
+        "UNAUTHENTICATED",
+        "API key is required for this operation. Pass apiKey in the constructor.",
+        401
+      );
+    }
+  }
+  async _request(method, path, options) {
+    let url = `${this.baseUrl}${path}`;
+    if (options?.query) {
+      const params = new URLSearchParams();
+      for (const [key, value] of Object.entries(options.query)) {
+        if (value !== void 0 && value !== null) {
+          params.set(key, String(value));
+        }
+      }
+      const qs = params.toString();
+      if (qs) {
+        url += `?${qs}`;
+      }
+    }
+    const headers = {};
+    if (this.apiKey) {
+      headers["X-Alva-Api-Key"] = this.apiKey;
+    }
+    let fetchBody;
+    if (options?.rawBody !== void 0) {
+      headers["Content-Type"] = "application/octet-stream";
+      fetchBody = options.rawBody;
+    } else if (options?.body !== void 0) {
+      headers["Content-Type"] = "application/json";
+      fetchBody = JSON.stringify(options.body);
+    }
+    let response;
+    try {
+      response = await fetch(url, {
+        method,
+        headers,
+        body: fetchBody
+      });
+    } catch (err) {
+      throw new AlvaError(
+        "NETWORK_ERROR",
+        err instanceof Error ? err.message : "Network request failed",
+        0
+      );
+    }
+    if (!response.ok) {
+      const bodyText = await response.text().catch(() => "");
+      const contentType2 = response.headers.get("content-type") ?? "";
+      if (contentType2.includes("application/json") && bodyText) {
+        try {
+          const data = JSON.parse(bodyText);
+          if (data.error) {
+            throw new AlvaError(
+              data.error.code ?? "UNKNOWN",
+              data.error.message ?? `HTTP ${response.status}`,
+              response.status
+            );
+          }
+        } catch (e) {
+          if (e instanceof AlvaError) throw e;
+        }
+      }
+      throw new AlvaError(
+        "UNKNOWN",
+        `HTTP ${response.status}: ${bodyText.slice(0, 200)}`,
+        response.status
+      );
+    }
+    if (response.status === 204) {
+      return void 0;
+    }
+    const contentType = response.headers.get("content-type") ?? "";
+    if (contentType.includes("application/octet-stream") || contentType.includes("image/")) {
+      return response.arrayBuffer();
+    }
+    return response.json();
+  }
+};
+
+// src/cli/config.ts
+function configPath(deps) {
+  const configDir2 = deps.env.XDG_CONFIG_HOME || `${deps.homedir()}/.config`;
+  return `${configDir2}/alva/config.json`;
+}
+function configDir(deps) {
+  const configRoot = deps.env.XDG_CONFIG_HOME || `${deps.homedir()}/.config`;
+  return `${configRoot}/alva`;
+}
+function readConfigFile(raw) {
+  const parsed = JSON.parse(raw);
+  return parsed;
+}
+function getProfile(config, profileName) {
+  if (config.profiles && config.profiles[profileName]) {
+    return config.profiles[profileName];
+  }
+  if (profileName === "default" && config.apiKey) {
+    return { apiKey: config.apiKey, baseUrl: config.baseUrl };
+  }
+  return {};
+}
+async function writeConfig(config, deps, profileName = "default") {
+  const path = configPath(deps);
+  const dir = configDir(deps);
+  let existing = {};
+  try {
+    const raw = await deps.readFile(path);
+    existing = readConfigFile(raw);
+  } catch {
+  }
+  if (!existing.profiles) {
+    existing.profiles = {};
+    if (existing.apiKey) {
+      existing.profiles["default"] = {
+        apiKey: existing.apiKey,
+        baseUrl: existing.baseUrl
+      };
+    }
+  }
+  const profileData = {
+    ...existing.profiles[profileName] || {},
+    apiKey: config.apiKey
+  };
+  if (config.baseUrl) {
+    profileData.baseUrl = config.baseUrl;
+  } else if (!existing.profiles[profileName]?.baseUrl) {
+    delete profileData.baseUrl;
+  }
+  existing.profiles[profileName] = profileData;
+  const output = { profiles: existing.profiles };
+  await deps.mkdir(dir, { recursive: true });
+  await deps.writeFile(path, JSON.stringify(output, null, 2) + "\n", {
+    mode: 384
+  });
+  return {
+    apiKey: profileData.apiKey,
+    baseUrl: profileData.baseUrl,
+    profile: profileName
+  };
+}
+function parseFlag(argv, flag) {
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] === flag && i + 1 < argv.length) {
+      return argv[i + 1];
+    }
+    if (argv[i].startsWith(`${flag}=`)) {
+      return argv[i].slice(flag.length + 1);
+    }
+  }
+  return void 0;
+}
+function loadConfig(deps) {
+  const { argv, env, readFile: readFile2, homedir: homedir2 } = deps;
+  const profileName = parseFlag(argv, "--profile") || env.ALVA_PROFILE || "default";
+  const baseUrlFlag = parseFlag(argv, "--base-url");
+  const baseUrlEnv = env.ALVA_ENDPOINT;
+  const apiKeyFlag = parseFlag(argv, "--api-key");
+  const apiKeyEnv = env.ALVA_API_KEY;
+  let fileProfile = {};
+  const path = configPath({ env, homedir: homedir2 });
+  try {
+    const raw = readFile2(path);
+    let config;
+    try {
+      config = readConfigFile(raw);
+    } catch {
+      throw new Error(`Failed to parse ${path}: invalid JSON`);
+    }
+    fileProfile = getProfile(config, profileName);
+  } catch (e) {
+    if (e instanceof Error && e.message.startsWith("Failed to parse")) {
+      throw e;
+    }
+  }
+  return {
+    apiKey: apiKeyFlag ?? apiKeyEnv ?? fileProfile.apiKey,
+    baseUrl: baseUrlFlag ?? baseUrlEnv ?? fileProfile.baseUrl,
+    profile: profileName
+  };
+}
+
+// src/cli/index.ts
+import * as fs from "fs";
+import * as os from "os";
+import * as fsPromises from "fs/promises";
+var HELP_TEXT = `Usage: alva <command> [options]
+
+Commands:
+  configure   Save API key and endpoint to a named profile
+  whoami      Verify credentials and show current user info
+  user        User profile operations
+  fs          Filesystem operations (read, write, stat, readdir, mkdir, remove, rename, copy, symlink, readlink, chmod, grant, revoke)
+  run         Execute code in the Alva runtime
+  deploy      Cronjob management (create, list, get, update, delete, pause, resume)
+  release     Feed and playbook releases (feed, playbook-draft, playbook)
+  secrets     Secret management (create, list, get, update, delete)
+  sdk         SDK documentation (doc, partitions, partition-summary)
+  comments    Playbook comments (create, pin, unpin)
+  remix       Save playbook remix lineage
+  screenshot  Capture a web screenshot as PNG
+
+Global options:
+  --api-key <key>      API key (overrides env and config file)
+  --base-url <url>     API base URL (overrides env and config file)
+  --profile <name>     Named profile to use (default: "default")
+  --help               Show help (use 'alva <command> --help' for command details)
+
+Config resolution: --api-key flag > ALVA_API_KEY env > profile in ~/.config/alva/config.json
+Profile resolution: --profile flag > ALVA_PROFILE env > "default"
+
+Quick start:
+  npm install -g @alva-ai/toolkit
+  alva configure --api-key alva_your_key_here
+  alva whoami`;
+var COMMAND_HELP = {
+  configure: `Usage: alva configure --api-key <key> [--base-url <url>] [--profile <name>]
+
+Save API credentials to ~/.config/alva/config.json (mode 0600).
+After configuring, subsequent commands use the saved key automatically.
+Multiple profiles allow switching between environments (production, staging, etc.).
+
+Required:
+  --api-key <key>      Your Alva API key (starts with "alva_")
+
+Optional:
+  --base-url <url>     API base URL (default: https://api-llm.prd.alva.ai)
+  --profile <name>     Profile name to save under (default: "default")
+
+Config file format:
+  {
+    "profiles": {
+      "default": { "apiKey": "alva_...", "baseUrl": "https://api-llm.prd.alva.ai" },
+      "staging": { "apiKey": "alva_...", "baseUrl": "https://api-llm.stg.alva.ai" }
+    }
+  }
+
+Examples:
+  alva configure --api-key alva_abc123
+  alva configure --api-key alva_abc123 --base-url http://localhost:8080
+  alva configure --profile staging --api-key alva_stg_key --base-url https://api-llm.stg.alva.ai
+  alva --profile staging whoami`,
+  whoami: `Usage: alva whoami [--profile <name>]
+
+Verify that your credentials are valid by calling the Alva API. Shows your
+username, subscription tier, and which profile/endpoint is being used.
+Use this after 'alva configure' to confirm everything works.
+
+Examples:
+  alva whoami
+  alva --profile staging whoami`,
+  user: `Usage: alva user <subcommand>
+
+Subcommands:
+  me    Get the authenticated user's profile
+
+Response fields:
+  id                  User ID
+  username            Username (used in ALFS paths and playbook URLs)
+  subscription_tier   "free" or "pro" \u2014 determines release flow and feature gates
+  telegram_username   Telegram username if connected, null otherwise
+
+Examples:
+  alva user me`,
+  fs: `Usage: alva fs <subcommand> [options]
+
+Subcommands:
+  read       Read a file or time series data
+  write      Write content to a file (use --data for inline, --file for upload)
+  stat       Get file metadata (name, size, mode, mod_time, is_dir)
+  readdir    List directory contents
+  mkdir      Create a directory (recursive by default)
+  remove     Delete a file or directory
+  rename     Move/rename a file
+  copy       Copy a file
+  symlink    Create a symbolic link
+  readlink   Read a symlink target
+  chmod      Change file permissions (mode is octal, e.g. 755)
+  grant      Grant access permission to a user or group
+  revoke     Revoke access permission
+
+Common flags:
+  --path <path>          File or directory path (required for most subcommands)
+  --recursive            Enable recursive operation (readdir, remove)
+  --no-recursive         Disable recursive operation
+  --mkdir-parents        Create parent directories on write
+
+Path conventions:
+  ~/...                  Home-relative path (expands to /alva/home/<username>/...)
+  /alva/home/alice/...   Absolute path (required for public/unauthenticated reads)
+
+Time series reads:
+  Paths under feed data directories support virtual suffixes:
+    @last/{n}            Last N data points (chronological order)
+    @range/{start}..{end}  Between timestamps (RFC 3339 or Unix ms)
+    @range/{duration}    Recent data within duration (e.g. 7d, 1h)
+    @count               Data point count
+    @now                 Latest single data point
+
+Grant/revoke subjects:
+  special:user:*         Public (anyone, including unauthenticated)
+  special:user:+         Any authenticated user
+  user:<id>              Specific user by ID
+
+Examples:
+  alva fs readdir --path ~/
+  alva fs readdir --path ~/data --recursive
+  alva fs read --path ~/data/prices.json
+  alva fs read --path ~/feeds/btc-ema/v1/data/metrics/prices/@last/100
+  alva fs read --path /alva/home/alice/feeds/btc-ema/v1/data/metrics/prices/@last/10
+  alva fs write --path ~/hello.txt --data "Hello, world!"
+  alva fs write --path ~/feeds/my-feed/v1/src/index.js --file ./local-script.js --mkdir-parents
+  alva fs stat --path ~/hello.txt
+  alva fs mkdir --path ~/feeds/my-feed/v1/src
+  alva fs remove --path ~/old-folder --recursive
+  alva fs rename --old-path ~/a.txt --new-path ~/b.txt
+  alva fs copy --src-path ~/a.txt --dst-path ~/b.txt
+  alva fs chmod --path ~/script.js --mode 755
+  alva fs grant --path ~/feeds/btc-ema --subject "special:user:*" --permission read
+  alva fs revoke --path ~/feeds/btc-ema --subject "special:user:*" --permission read`,
+  run: `Usage: alva run [options]
+
+Execute JavaScript code in the Alva V8 runtime. Provide either inline code
+or a path to a script file on ALFS. Scripts have access to 250+ financial
+data SDKs, ALFS, HTTP networking, and the Feed SDK.
+
+Options:
+  --code <code>          Inline JavaScript code to execute
+  --entry-path <path>    Path to a script file on ALFS (home-relative)
+  --working-dir <dir>    Working directory for require() (inline code only)
+  --args <json>          JSON object passed to require("env").args
+
+At least one of --code or --entry-path is required.
+
+Response fields:
+  result    JSON-encoded return value of the script
+  logs      Captured stderr output
+  status    "completed" or "failed"
+  error     Error message (when status is "failed")
+
+Available runtime modules:
+  require("alfs")            Cloud filesystem (absolute paths only)
+  require("env")             userId, username, args from request
+  require("net/http")        fetch(url, init) for HTTP requests
+  require("secret-manager")  Read user-scoped third-party secrets
+  require("@alva/feed")      Feed SDK for data pipelines
+  require("@alva/algorithm") 50+ technical indicators
+  require("@alva/adk")       Agent SDK for LLM tool calling
+  require("@arrays/...")     250+ financial data SDKs
+
+Constraints:
+  No top-level await \u2014 wrap in (async () => { ... })();
+  No Node.js builtins (fs, path, http) \u2014 use alfs, net/http instead
+  2 GB heap limit per execution
+
+Examples:
+  alva run --code "1 + 2 + 3;"
+  alva run --code "JSON.stringify(require('env').args);" --args '{"symbol":"BTC"}'
+  alva run --entry-path ~/feeds/my-feed/v1/src/index.js
+  alva run --entry-path ~/tasks/analyze/src/index.js --args '{"symbol":"NVDA","limit":50}'`,
+  deploy: `Usage: alva deploy <subcommand> [options]
+
+Manage scheduled cronjobs that run your scripts on a cron schedule.
+Max 20 cronjobs per user. Min interval: 1 minute.
+
+Subcommands:
+  create     Create a new cronjob
+  list       List all cronjobs (supports cursor-based pagination)
+  get        Get a single cronjob by ID
+  update     Update a cronjob (partial update \u2014 only include changed fields)
+  delete     Delete a cronjob
+  pause      Pause a running cronjob
+  resume     Resume a paused cronjob
+
+Create flags:
+  --name <name>          Cronjob name (required, 1-63 lowercase alphanumeric/hyphens)
+  --path <path>          Path to script on ALFS (required, must exist)
+  --cron <expression>    Cron expression (required, e.g. "0 */4 * * *")
+  --args <json>          JSON object passed to require("env").args
+  --push-notify          Enable Telegram push notifications on completion
+  --no-push-notify       Disable push notifications
+
+List flags:
+  --limit <n>            Max results per page (default: 20)
+  --cursor <cursor>      Pagination cursor from previous response
+
+Get/Update/Delete/Pause/Resume flags:
+  --id <id>              Cronjob ID (required)
+
+Name format: 1-63 lowercase alphanumeric or hyphens, no leading/trailing hyphens.
+  Valid:   btc-ema-update, my-strategy-1
+  Invalid: BTC EMA, -my-job-, my_job
+
+Recommended cron schedules:
+  "0 */4 * * *"    Every 4 hours (stock OHLCV, crypto technicals)
+  "0 8 * * *"      Daily at 8am (fundamentals, insider trades, earnings)
+  "*/5 * * * *"    Every 5 minutes (high-frequency alerts)
+  "0 0 * * *"      Daily at midnight (end-of-day summaries)
+
+Examples:
+  alva deploy create --name btc-ema --path ~/feeds/btc-ema/v1/src/index.js --cron "0 */4 * * *"
+  alva deploy create --name alert --path ~/feeds/alert/v1/src/index.js --cron "*/5 * * * *" --push-notify --args '{"threshold":100}'
+  alva deploy list
+  alva deploy list --limit 10
+  alva deploy get --id 42
+  alva deploy update --id 42 --cron "0 */2 * * *" --no-push-notify
+  alva deploy pause --id 42
+  alva deploy resume --id 42
+  alva deploy delete --id 42`,
+  release: `Usage: alva release <subcommand> [options]
+
+Publish feeds and playbooks to the Alva platform. The typical workflow:
+  1. Deploy cronjob (alva deploy create)
+  2. Register feed (alva release feed)
+  3. Create playbook draft (alva release playbook-draft)
+  4. Write HTML to ALFS (alva fs write --path ~/playbooks/{name}/index.html)
+  5. Release playbook (alva release playbook)
+
+Subcommands:
+  feed              Register a feed after deploying its cronjob
+  playbook-draft    Create a playbook draft (preview before publishing)
+  playbook          Publish a playbook (public for free users, choice for pro)
+
+Feed flags:
+  --name <name>          Feed name, unique per user (required)
+  --version <version>    Semantic version, e.g. "1.0.0" (required)
+  --cronjob-id <id>      ID of the backing cronjob (required)
+  --view-json <json>     View configuration JSON
+  --description <text>   Feed description
+
+Playbook-draft flags:
+  --name <name>              URL-safe playbook name, unique per user (required)
+  --display-name <name>      Human-readable title, max 40 chars (required)
+  --feeds <json>             JSON array of {feed_id, feed_major?} (required)
+  --description <text>       Playbook description
+  --trading-symbols <json>   JSON array of tickers, e.g. '["BTC","ETH"]' (max 50)
+
+Playbook flags:
+  --name <name>          Playbook name, must already exist as draft (required)
+  --version <version>    Semantic version, e.g. "v1.0.0" (required)
+  --feeds <json>         JSON array of {feed_id, feed_major?} (required)
+  --changelog <text>     Release changelog (required)
+
+Display name conventions:
+  Format: [subject/theme] [analysis angle/strategy logic]
+  Max 40 characters. Avoid "My", "Test", or generic-only titles.
+  Good: "BTC Trend Dashboard", "NVDA Insider Activity Tracker"
+  Bad:  "My Dashboard", "Test V2", "Stock Dashboard"
+
+Examples:
+  alva release feed --name btc-ema --version 1.0.0 --cronjob-id 42
+  alva release feed --name nvda-insiders --version 1.0.0 --cronjob-id 43 --description "NVDA insider trading activity"
+  alva release playbook-draft --name btc-dashboard --display-name "BTC Trend Dashboard" --feeds '[{"feed_id":100}]' --trading-symbols '["BTC"]'
+  alva release playbook --name btc-dashboard --version v1.0.0 --feeds '[{"feed_id":100}]' --changelog "Initial release"`,
+  secrets: `Usage: alva secrets <subcommand> [options]
+
+Manage encrypted secrets for use in Alva scripts. Secrets are stored
+encrypted at rest and accessible via require("secret-manager") in the runtime.
+
+For sensitive secrets (API keys, tokens), prefer the web UI at https://alva.ai/apikey.
+Use the CLI for agent-managed CRUD operations.
+
+Subcommands:
+  create     Create a new secret (fails if name already exists)
+  list       List all secrets (metadata only: name, keyPrefix, timestamps)
+  get        Get a secret's plaintext value
+  update     Update a secret's value (fails if name doesn't exist)
+  delete     Delete a secret (fails if name doesn't exist)
+
+Flags:
+  --name <name>      Secret name (required for create, get, update, delete)
+  --value <value>    Secret value (required for create, update)
+
+Runtime usage in scripts:
+  const secret = require("secret-manager");
+  const key = secret.loadPlaintext("OPENAI_API_KEY");
+  // Returns string if found, null if missing
+
+Examples:
+  alva secrets create --name OPENAI_KEY --value sk-abc123
+  alva secrets list
+  alva secrets get --name OPENAI_KEY
+  alva secrets update --name OPENAI_KEY --value sk-new456
+  alva secrets delete --name OPENAI_KEY`,
+  sdk: `Usage: alva sdk <subcommand> [options]
+
+Browse Alva's 250+ financial data SDKs. Use the two-step discovery flow:
+  1. List partitions to find the right category
+  2. Get partition summary to see available modules
+  3. Get full documentation for a specific module
+
+Subcommands:
+  doc                 Get documentation for a specific SDK module
+  partitions          List all available data partitions
+  partition-summary   Get a summary of modules in a partition
+
+Flags:
+  --name <module>        Module name for 'doc' (required)
+  --partition <name>     Partition name for 'partition-summary' (required)
+
+Key partitions:
+  spot_market_price_and_volume         Spot OHLCV for crypto and equities
+  crypto_futures_data                  Perpetual futures, funding rates, OI
+  crypto_technical_metrics             MA, RSI, MACD, MVRV, SOPR, NUPL (20 modules)
+  equity_fundamentals                  Income, balance sheet, PE, ROE (31 modules)
+  equity_estimates_and_targets         Analyst targets, consensus estimates
+  equity_ownership_and_flow            Insider trades, senator trading, institutions
+  macro_and_economics_data             CPI, GDP, Treasury rates, VIX (20 modules)
+  technical_indicator_calculation_helpers  50+ pure calculators (RSI, MACD, Bollinger)
+
+Examples:
+  alva sdk partitions
+  alva sdk partition-summary --partition spot_market_price_and_volume
+  alva sdk doc --name "@arrays/crypto/ohlcv:v1.0.0"
+  alva sdk doc --name "@arrays/data/stock/ohlcv:v1.0.0"`,
+  comments: `Usage: alva comments <subcommand> [options]
+
+Manage comments on Alva playbooks. Supports top-level comments and threaded
+replies. One comment per playbook can be pinned (pinning a new one unpins
+the previous).
+
+Subcommands:
+  create     Post a comment on a playbook (or reply to an existing comment)
+  pin        Pin a top-level comment (owner/admin only)
+  unpin      Unpin a comment (owner/admin only)
+
+Create flags:
+  --username <user>      Playbook owner's username (required)
+  --name <name>          Playbook name (required)
+  --content <text>       Comment content (required)
+  --parent-id <id>       Parent comment ID (for threaded replies, omit for top-level)
+
+Pin/Unpin flags:
+  --comment-id <id>      Comment ID (required)
+
+Examples:
+  alva comments create --username alice --name btc-dashboard --content "Great analysis!"
+  alva comments create --username alice --name btc-dashboard --content "Thanks!" --parent-id 5
+  alva comments pin --comment-id 12
+  alva comments unpin --comment-id 12`,
+  remix: `Usage: alva remix --child-username <u> --child-name <n> --parents <json>
+
+Record remix lineage when creating a playbook based on existing playbooks.
+Call this after releasing a remixed playbook to establish the parent-child
+relationship in the database.
+
+Required:
+  --child-username <username>   Your username (the remixer)
+  --child-name <name>           Your new playbook name
+  --parents <json>              JSON array of source playbooks: [{"username":"...", "name":"..."}]
+
+Examples:
+  alva remix --child-username bob --child-name my-btc --parents '[{"username":"alice","name":"btc-signals"}]'`,
+  screenshot: `Usage: alva screenshot --url <url> --out <file> [--selector <css>] [--xpath <xpath>]
+
+Capture a screenshot of an Alva page and save it as PNG. Useful for verifying
+playbook rendering before release.
+
+Required:
+  --url <url>          URL or path to capture (e.g. /playbook/alice/dashboard)
+  --out <file>         Local file path to write the PNG output
+
+Optional:
+  --selector <css>     CSS selector to capture a specific element
+  --xpath <xpath>      XPath selector to capture a specific element
+
+Examples:
+  alva screenshot --url /playbook/alice/btc-dashboard --out dashboard.png
+  alva screenshot --url /playbook/alice/btc-dashboard --out chart.png --selector ".chart-container"`
+};
+async function handleConfigure(args, deps) {
+  const flags = parseFlags(args.slice(1));
+  const apiKey = flags["api-key"];
+  if (!apiKey) {
+    throw new Error(
+      "--api-key is required. Usage: alva configure --api-key <key> [--base-url <url>] [--profile <name>]"
+    );
+  }
+  if (!apiKey.startsWith("alva_")) {
+    process.stderr?.write?.(
+      'Warning: API key does not start with "alva_". This may not be a valid Alva API key.\n'
+    );
+  }
+  const baseUrl = flags["base-url"];
+  const profileName = flags["profile"] || "default";
+  const configInput = { apiKey };
+  if (baseUrl) configInput.baseUrl = baseUrl;
+  const writeDeps = deps ?? {
+    env: process.env,
+    homedir: () => os.homedir(),
+    mkdir: (path, options) => fsPromises.mkdir(path, options).then(() => void 0),
+    writeFile: (path, data, options) => fsPromises.writeFile(path, data, options).then(() => void 0),
+    readFile: (path) => fsPromises.readFile(path, "utf-8")
+  };
+  const result = await writeConfig(configInput, writeDeps, profileName);
+  return {
+    status: "configured",
+    apiKey: result.apiKey,
+    baseUrl: result.baseUrl,
+    profile: profileName
+  };
+}
+var BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
+  "recursive",
+  "mkdir-parents",
+  "push-notify",
+  "help"
+]);
+function parseFlags(argv) {
+  const flags = {};
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg.startsWith("--no-") && BOOLEAN_FLAGS.has(arg.slice(5))) {
+      flags[arg.slice(5)] = "false";
+    } else if (arg.startsWith("--")) {
+      const eqIdx = arg.indexOf("=");
+      if (eqIdx !== -1) {
+        flags[arg.slice(2, eqIdx)] = arg.slice(eqIdx + 1);
+      } else if (BOOLEAN_FLAGS.has(arg.slice(2))) {
+        flags[arg.slice(2)] = "true";
+      } else if (i + 1 < argv.length) {
+        flags[arg.slice(2)] = argv[i + 1];
+        i++;
+      }
+    }
+  }
+  return flags;
+}
+function boolFlag(val) {
+  if (val === "true") return true;
+  if (val === "false") return false;
+  return void 0;
+}
+function requireFlag(flags, name, command) {
+  const val = flags[name];
+  if (val === void 0) {
+    throw new Error(`--${name} is required for '${command}'`);
+  }
+  return val;
+}
+function requireNumericFlag(flags, name, command) {
+  const val = requireFlag(flags, name, command);
+  const n = Number(val);
+  if (Number.isNaN(n)) {
+    throw new Error(
+      `--${name} must be a number for '${command}', got '${val}'`
+    );
+  }
+  return n;
+}
+function num(val) {
+  if (val === void 0) return void 0;
+  const n = Number(val);
+  return Number.isNaN(n) ? void 0 : n;
+}
+function jsonParse(val) {
+  if (val === void 0) return void 0;
+  try {
+    return JSON.parse(val);
+  } catch {
+    return val;
+  }
+}
+async function dispatch(client, args, meta) {
+  const group = args[0];
+  if (!group || group === "--help" || group === "-h") {
+    return { _help: true, text: HELP_TEXT };
+  }
+  if (COMMAND_HELP[group] && (args[1] === "--help" || args[1] === "-h")) {
+    return { _help: true, text: COMMAND_HELP[group] };
+  }
+  if (group === "whoami") {
+    const user = await client.user.me();
+    return {
+      ...user,
+      _meta: {
+        profile: meta?.profile ?? "default",
+        endpoint: meta?.baseUrl ?? client.baseUrl
+      }
+    };
+  }
+  const subcommand = args[1];
+  const flags = parseFlags(
+    args.slice(
+      group === "run" || group === "remix" || group === "screenshot" ? 1 : 2
+    )
+  );
+  if (flags["help"] !== void 0) {
+    const helpText = COMMAND_HELP[group];
+    if (helpText) return { _help: true, text: helpText };
+  }
+  switch (group) {
+    case "user":
+      if (!subcommand) throw new Error("Missing subcommand for user");
+      if (subcommand === "me") return client.user.me();
+      throw new Error(`Unknown subcommand: user ${subcommand}`);
+    case "fs": {
+      if (!subcommand) throw new Error("Missing subcommand for fs");
+      switch (subcommand) {
+        case "read":
+          return client.fs.read({
+            path: requireFlag(flags, "path", "fs read"),
+            offset: num(flags["offset"]),
+            size: num(flags["size"])
+          });
+        case "write":
+          if (flags["file"]) {
+            const fileData = fs.readFileSync(flags["file"]);
+            return client.fs.rawWrite({
+              path: requireFlag(flags, "path", "fs write"),
+              body: fileData,
+              mkdir_parents: boolFlag(flags["mkdir-parents"])
+            });
+          }
+          return client.fs.write({
+            path: requireFlag(flags, "path", "fs write"),
+            data: requireFlag(flags, "data", "fs write"),
+            mkdir_parents: boolFlag(flags["mkdir-parents"])
+          });
+        case "stat":
+          return client.fs.stat({
+            path: requireFlag(flags, "path", "fs stat")
+          });
+        case "readdir":
+          return client.fs.readdir({
+            path: requireFlag(flags, "path", "fs readdir"),
+            recursive: boolFlag(flags["recursive"])
+          });
+        case "mkdir":
+          return client.fs.mkdir({
+            path: requireFlag(flags, "path", "fs mkdir")
+          });
+        case "remove":
+          return client.fs.remove({
+            path: requireFlag(flags, "path", "fs remove"),
+            recursive: boolFlag(flags["recursive"])
+          });
+        case "rename":
+          return client.fs.rename({
+            old_path: requireFlag(flags, "old-path", "fs rename"),
+            new_path: requireFlag(flags, "new-path", "fs rename")
+          });
+        case "copy":
+          return client.fs.copy({
+            src_path: requireFlag(flags, "src-path", "fs copy"),
+            dst_path: requireFlag(flags, "dst-path", "fs copy")
+          });
+        case "symlink":
+          return client.fs.symlink({
+            target_path: requireFlag(flags, "target-path", "fs symlink"),
+            link_path: requireFlag(flags, "link-path", "fs symlink")
+          });
+        case "readlink":
+          return client.fs.readlink({
+            path: requireFlag(flags, "path", "fs readlink")
+          });
+        case "chmod":
+          return client.fs.chmod({
+            path: requireFlag(flags, "path", "fs chmod"),
+            mode: parseInt(requireFlag(flags, "mode", "fs chmod"), 8)
+          });
+        case "grant":
+          return client.fs.grant({
+            path: requireFlag(flags, "path", "fs grant"),
+            subject: requireFlag(flags, "subject", "fs grant"),
+            permission: requireFlag(flags, "permission", "fs grant")
+          });
+        case "revoke":
+          return client.fs.revoke({
+            path: requireFlag(flags, "path", "fs revoke"),
+            subject: requireFlag(flags, "subject", "fs revoke"),
+            permission: requireFlag(flags, "permission", "fs revoke")
+          });
+        default:
+          throw new Error(`Unknown subcommand: fs ${subcommand}`);
+      }
+    }
+    case "run":
+      return client.run.execute({
+        code: flags["code"],
+        entry_path: flags["entry-path"],
+        working_dir: flags["working-dir"],
+        args: jsonParse(flags["args"])
+      });
+    case "deploy": {
+      if (!subcommand) throw new Error("Missing subcommand for deploy");
+      switch (subcommand) {
+        case "create":
+          return client.deploy.create({
+            name: requireFlag(flags, "name", "deploy create"),
+            path: requireFlag(flags, "path", "deploy create"),
+            cron_expression: requireFlag(flags, "cron", "deploy create"),
+            args: jsonParse(flags["args"]),
+            push_notify: boolFlag(flags["push-notify"])
+          });
+        case "list":
+          return client.deploy.list({
+            limit: num(flags["limit"]),
+            cursor: flags["cursor"]
+          });
+        case "get":
+          return client.deploy.get({
+            id: requireNumericFlag(flags, "id", "deploy get")
+          });
+        case "update":
+          return client.deploy.update({
+            id: requireNumericFlag(flags, "id", "deploy update"),
+            name: flags["name"],
+            cron_expression: flags["cron"],
+            args: jsonParse(flags["args"]),
+            push_notify: boolFlag(flags["push-notify"])
+          });
+        case "delete":
+          return client.deploy.delete({
+            id: requireNumericFlag(flags, "id", "deploy delete")
+          });
+        case "pause":
+          return client.deploy.pause({
+            id: requireNumericFlag(flags, "id", "deploy pause")
+          });
+        case "resume":
+          return client.deploy.resume({
+            id: requireNumericFlag(flags, "id", "deploy resume")
+          });
+        default:
+          throw new Error(`Unknown subcommand: deploy ${subcommand}`);
+      }
+    }
+    case "release": {
+      if (!subcommand) throw new Error("Missing subcommand for release");
+      switch (subcommand) {
+        case "feed":
+          return client.release.feed({
+            name: requireFlag(flags, "name", "release feed"),
+            version: requireFlag(flags, "version", "release feed"),
+            cronjob_id: requireNumericFlag(flags, "cronjob-id", "release feed"),
+            view_json: jsonParse(flags["view-json"]),
+            description: flags["description"]
+          });
+        case "playbook-draft":
+          return client.release.playbookDraft({
+            name: requireFlag(flags, "name", "release playbook-draft"),
+            display_name: requireFlag(
+              flags,
+              "display-name",
+              "release playbook-draft"
+            ),
+            description: flags["description"],
+            feeds: jsonParse(
+              requireFlag(flags, "feeds", "release playbook-draft")
+            ),
+            trading_symbols: flags["trading-symbols"] ? jsonParse(flags["trading-symbols"]) : void 0
+          });
+        case "playbook":
+          return client.release.playbook({
+            name: requireFlag(flags, "name", "release playbook"),
+            version: requireFlag(flags, "version", "release playbook"),
+            feeds: jsonParse(
+              requireFlag(flags, "feeds", "release playbook")
+            ),
+            changelog: requireFlag(flags, "changelog", "release playbook")
+          });
+        default:
+          throw new Error(`Unknown subcommand: release ${subcommand}`);
+      }
+    }
+    case "secrets": {
+      if (!subcommand) throw new Error("Missing subcommand for secrets");
+      switch (subcommand) {
+        case "create":
+          return client.secrets.create({
+            name: requireFlag(flags, "name", "secrets create"),
+            value: requireFlag(flags, "value", "secrets create")
+          });
+        case "list":
+          return client.secrets.list();
+        case "get":
+          return client.secrets.get({
+            name: requireFlag(flags, "name", "secrets get")
+          });
+        case "update":
+          return client.secrets.update({
+            name: requireFlag(flags, "name", "secrets update"),
+            value: requireFlag(flags, "value", "secrets update")
+          });
+        case "delete":
+          return client.secrets.delete({
+            name: requireFlag(flags, "name", "secrets delete")
+          });
+        default:
+          throw new Error(`Unknown subcommand: secrets ${subcommand}`);
+      }
+    }
+    case "sdk": {
+      if (!subcommand) throw new Error("Missing subcommand for sdk");
+      switch (subcommand) {
+        case "doc":
+          return client.sdk.doc({
+            name: requireFlag(flags, "name", "sdk doc")
+          });
+        case "partitions":
+          return client.sdk.partitions();
+        case "partition-summary":
+          return client.sdk.partitionSummary({
+            partition: requireFlag(flags, "partition", "sdk partition-summary")
+          });
+        default:
+          throw new Error(`Unknown subcommand: sdk ${subcommand}`);
+      }
+    }
+    case "comments": {
+      if (!subcommand) throw new Error("Missing subcommand for comments");
+      switch (subcommand) {
+        case "create":
+          return client.comments.create({
+            username: requireFlag(flags, "username", "comments create"),
+            name: requireFlag(flags, "name", "comments create"),
+            content: requireFlag(flags, "content", "comments create"),
+            parent_id: num(flags["parent-id"])
+          });
+        case "pin":
+          return client.comments.pin({
+            comment_id: requireNumericFlag(flags, "comment-id", "comments pin")
+          });
+        case "unpin":
+          return client.comments.unpin({
+            comment_id: requireNumericFlag(
+              flags,
+              "comment-id",
+              "comments unpin"
+            )
+          });
+        default:
+          throw new Error(`Unknown subcommand: comments ${subcommand}`);
+      }
+    }
+    case "remix":
+      return client.remix.save({
+        child: {
+          username: requireFlag(flags, "child-username", "remix"),
+          name: requireFlag(flags, "child-name", "remix")
+        },
+        parents: jsonParse(requireFlag(flags, "parents", "remix"))
+      });
+    case "screenshot": {
+      const outFile = requireFlag(flags, "out", "screenshot");
+      const result = await client.screenshot.capture({
+        url: requireFlag(flags, "url", "screenshot"),
+        selector: flags["selector"],
+        xpath: flags["xpath"]
+      });
+      const buf = Buffer.from(result);
+      fs.writeFileSync(outFile, buf);
+      return { written: outFile, bytes: buf.length };
+    }
+    default:
+      throw new Error(
+        `Unknown command: '${group}'. Run 'alva --help' to see available commands.`
+      );
+  }
+}
+async function main() {
+  try {
+    const rawArgs = process.argv.slice(2);
+    if (rawArgs[0] === "configure") {
+      if (rawArgs[1] === "--help" || rawArgs[1] === "-h") {
+        process.stdout.write(COMMAND_HELP["configure"] + "\n");
+        return;
+      }
+      const result2 = await handleConfigure(rawArgs);
+      process.stdout.write(JSON.stringify(result2, null, 2) + "\n");
+      return;
+    }
+    const config = loadConfig({
+      argv: rawArgs,
+      env: process.env,
+      readFile: (path) => fs.readFileSync(path, "utf-8"),
+      homedir: () => os.homedir()
+    });
+    const client = new AlvaClient({
+      apiKey: config.apiKey,
+      baseUrl: config.baseUrl
+    });
+    const cleanArgs = [];
+    for (let i = 0; i < rawArgs.length; i++) {
+      const a = rawArgs[i];
+      if (a === "--api-key" || a === "--base-url" || a === "--profile") {
+        i++;
+        continue;
+      }
+      if (a.startsWith("--api-key=") || a.startsWith("--base-url=") || a.startsWith("--profile=")) {
+        continue;
+      }
+      cleanArgs.push(a);
+    }
+    const result = await dispatch(client, cleanArgs, {
+      profile: config.profile,
+      baseUrl: config.baseUrl
+    });
+    if (result && typeof result === "object" && "_help" in result) {
+      const helpResult = result;
+      process.stdout.write(helpResult.text + "\n");
+      return;
+    }
+    if (result !== void 0) {
+      process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+    }
+  } catch (err) {
+    const error = err instanceof AlvaError ? { code: err.code, message: err.message, status: err.status } : {
+      code: "CLI_ERROR",
+      message: err instanceof Error ? err.message : String(err)
+    };
+    process.stderr.write(JSON.stringify({ error }, null, 2) + "\n");
+    process.exit(1);
+  }
+}
+var isDirectRun = typeof process !== "undefined" && process.argv[1] && (process.argv[1].endsWith("cli.mjs") || process.argv[1].endsWith("cli.js") || process.argv[1].endsWith("/alva") || process.argv[1].endsWith("\\alva"));
+if (isDirectRun) {
+  main();
+}
+export {
+  dispatch,
+  handleConfigure
+};
+//# sourceMappingURL=cli.js.map