@insforge/cli 0.1.41 → 0.1.43

package/dist/index.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { readFileSync as readFileSync6 } from "fs";
-import { join as join7, dirname } from "path";
+import { readFileSync as readFileSync7 } from "fs";
+import { join as join8, dirname } from "path";
 import { fileURLToPath } from "url";
 import { Command } from "commander";
 import * as clack14 from "@clack/prompts";
@@ -797,6 +797,47 @@ async function reportCliUsage(toolName, success, maxRetries = 1) {
   }
 }
 
+// src/lib/analytics.ts
+import { PostHog } from "posthog-node";
+var POSTHOG_API_KEY = "phc_ueV1ii62wdBTkH7E70ugyeqHIHu8dFDdjs0qq3TZhJz";
+var POSTHOG_HOST = process.env.POSTHOG_HOST || "https://us.i.posthog.com";
+var client = null;
+function getClient() {
+  if (!POSTHOG_API_KEY) return null;
+  if (!client) {
+    client = new PostHog(POSTHOG_API_KEY, { host: POSTHOG_HOST });
+  }
+  return client;
+}
+function captureEvent(distinctId, event, properties) {
+  try {
+    getClient()?.capture({ distinctId, event, properties });
+  } catch {
+  }
+}
+function trackCommand(command, distinctId, properties) {
+  captureEvent(distinctId, "cli_command_invoked", {
+    command,
+    ...properties
+  });
+}
+function trackDiagnose(subcommand, config) {
+  captureEvent(config.project_id, "cli_diagnose_invoked", {
+    subcommand,
+    project_id: config.project_id,
+    project_name: config.project_name,
+    org_id: config.org_id,
+    region: config.region,
+    oss_mode: config.project_id === "oss-project"
+  });
+}
+async function shutdownAnalytics() {
+  try {
+    if (client) await client.shutdown();
+  } catch {
+  }
+}
+
 // src/commands/projects/link.ts
 function buildOssHost(appkey, region) {
   return `https://${appkey}.${region}.insforge.app`;
@@ -831,6 +872,7 @@ function registerProjectLinkCommand(program2) {
           } else {
             outputSuccess(`Linked to direct project at ${projectConfig2.oss_host}`);
           }
+          trackCommand("link", "oss-org", { direct: true });
           await installSkills(json);
           await reportCliUsage("cli.link_direct", true, 6);
           try {
@@ -916,6 +958,7 @@ function registerProjectLinkCommand(program2) {
         oss_host: buildOssHost(project.appkey, project.region)
       };
       saveProjectConfig(projectConfig);
+      trackCommand("link", project.organization_id);
       if (json) {
         outputJson({ success: true, project: { id: project.id, name: project.name, region: project.region } });
       } else {
@@ -930,6 +973,8 @@ function registerProjectLinkCommand(program2) {
     } catch (err) {
       await reportCliUsage("cli.link", false);
       handleError(err, json);
+    } finally {
+      await shutdownAnalytics();
     }
   });
 }
@@ -967,7 +1012,15 @@ async function ossFetch(path4, options = {}) {
   const res = await fetch(`${config.oss_host}${path4}`, { ...options, headers });
   if (!res.ok) {
     const err = await res.json().catch(() => ({}));
-    throw new CLIError(err.error ?? `OSS request failed: ${res.status}`);
+    let message = err.message ?? err.error ?? `OSS request failed: ${res.status}`;
+    if (err.nextActions) {
+      message += `
+${err.nextActions}`;
+    }
+    if (res.status === 404 && path4.startsWith("/api/compute")) {
+      message = "Compute services are not available on this backend.\nSelf-hosted: upgrade your InsForge instance. Cloud: contact your InsForge admin to enable compute.";
+    }
+    throw new CLIError(message);
   }
   return res;
 }
@@ -1896,41 +1949,6 @@ async function readEnvFile(cwd) {
   return [];
 }
 
-// src/lib/analytics.ts
-import { PostHog } from "posthog-node";
-var POSTHOG_API_KEY = "phc_ueV1ii62wdBTkH7E70ugyeqHIHu8dFDdjs0qq3TZhJz";
-var POSTHOG_HOST = process.env.POSTHOG_HOST || "https://us.i.posthog.com";
-var client = null;
-function getClient() {
-  if (!POSTHOG_API_KEY) return null;
-  if (!client) {
-    client = new PostHog(POSTHOG_API_KEY, { host: POSTHOG_HOST });
-  }
-  return client;
-}
-function captureEvent(distinctId, event, properties) {
-  try {
-    getClient()?.capture({ distinctId, event, properties });
-  } catch {
-  }
-}
-function trackDiagnose(subcommand, config) {
-  captureEvent(config.project_id, "cli_diagnose_invoked", {
-    subcommand,
-    project_id: config.project_id,
-    project_name: config.project_name,
-    org_id: config.org_id,
-    region: config.region,
-    oss_mode: config.project_id === "oss-project"
-  });
-}
-async function shutdownAnalytics() {
-  try {
-    if (client) await client.shutdown();
-  } catch {
-  }
-}
-
 // src/commands/deployments/deploy.ts
 import * as path2 from "path";
 import * as fs2 from "fs/promises";
@@ -2363,6 +2381,7 @@ function registerCreateCommand(program2) {
         }
       }
       await installSkills(json);
+      trackCommand("create", orgId);
       await reportCliUsage("cli.create", true, 6);
       if (hasTemplate) {
         const installSpinner = !json ? clack10.spinner() : null;
@@ -3271,6 +3290,445 @@ function registerSchedulesLogsCommand(schedulesCmd2) {
   });
 }
 
+// src/commands/compute/list.ts
+function registerComputeListCommand(computeCmd2) {
+  computeCmd2.command("list").description("List all compute services").action(async (_opts, cmd) => {
+    const { json } = getRootOpts(cmd);
+    try {
+      await requireAuth();
+      const res = await ossFetch("/api/compute/services");
+      const raw = await res.json();
+      const services = Array.isArray(raw) ? raw : [];
+      if (json) {
+        outputJson(services);
+      } else {
+        if (services.length === 0) {
+          console.log("No compute services found.");
+          await reportCliUsage("cli.compute.list", true);
+          return;
+        }
+        outputTable(
+          ["Name", "Status", "Image", "CPU", "Memory", "Endpoint"],
+          services.map((s) => [
+            String(s.name ?? "-"),
+            String(s.status ?? "-"),
+            String(s.imageUrl ?? "-"),
+            String(s.cpu ?? "-"),
+            s.memory ? `${s.memory}MB` : "-",
+            String(s.endpointUrl ?? "-")
+          ])
+        );
+      }
+      await reportCliUsage("cli.compute.list", true);
+    } catch (err) {
+      await reportCliUsage("cli.compute.list", false);
+      handleError(err, json);
+    }
+  });
+}
+
+// src/commands/compute/get.ts
+function registerComputeGetCommand(computeCmd2) {
+  computeCmd2.command("get <id>").description("Get details of a compute service").action(async (id, _opts, cmd) => {
+    const { json } = getRootOpts(cmd);
+    try {
+      await requireAuth();
+      const res = await ossFetch(`/api/compute/services/${encodeURIComponent(id)}`);
+      const service = await res.json();
+      if (json) {
+        outputJson(service);
+      } else {
+        outputInfo(`Name:      ${service.name}`);
+        outputInfo(`ID:        ${service.id}`);
+        outputInfo(`Status:    ${service.status}`);
+        outputInfo(`Image:     ${service.imageUrl}`);
+        outputInfo(`CPU:       ${service.cpu}`);
+        outputInfo(`Memory:    ${service.memory}MB`);
+        outputInfo(`Region:    ${service.region}`);
+        outputInfo(`Endpoint:  ${service.endpointUrl ?? "n/a"}`);
+        outputInfo(`Created:   ${service.createdAt}`);
+      }
+      await reportCliUsage("cli.compute.get", true);
+    } catch (err) {
+      await reportCliUsage("cli.compute.get", false);
+      handleError(err, json);
+    }
+  });
+}
+
+// src/commands/compute/create.ts
+function registerComputeCreateCommand(computeCmd2) {
+  computeCmd2.command("create").description("Create and deploy a compute service").requiredOption("--name <name>", "Service name (DNS-safe, e.g. my-api)").requiredOption("--image <image>", "Docker image URL (e.g. nginx:alpine)").option("--port <port>", "Container port", "8080").option("--cpu <tier>", "CPU tier (shared-1x, shared-2x, performance-1x, performance-2x, performance-4x)", "shared-1x").option("--memory <mb>", "Memory in MB (256, 512, 1024, 2048, 4096, 8192)", "512").option("--region <region>", "Fly.io region", "iad").option("--env <json>", "Environment variables as JSON object").action(async (opts, cmd) => {
+    const { json } = getRootOpts(cmd);
+    try {
+      await requireAuth();
+      const body = {
+        name: opts.name,
+        imageUrl: opts.image,
+        port: Number(opts.port),
+        cpu: opts.cpu,
+        memory: Number(opts.memory),
+        region: opts.region
+      };
+      if (opts.env) {
+        try {
+          body.envVars = JSON.parse(opts.env);
+        } catch {
+          throw new CLIError("Invalid JSON for --env");
+        }
+      }
+      const res = await ossFetch("/api/compute/services", {
+        method: "POST",
+        body: JSON.stringify(body)
+      });
+      const service = await res.json();
+      if (json) {
+        outputJson(service);
+      } else {
+        outputSuccess(`Service "${service.name}" created [${service.status}]`);
+        if (service.endpointUrl) {
+          console.log(`  Endpoint: ${service.endpointUrl}`);
+        }
+      }
+      await reportCliUsage("cli.compute.create", true);
+    } catch (err) {
+      await reportCliUsage("cli.compute.create", false);
+      handleError(err, json);
+    }
+  });
+}
+
+// src/commands/compute/update.ts
+function registerComputeUpdateCommand(computeCmd2) {
+  computeCmd2.command("update <id>").description("Update a compute service").option("--image <image>", "Docker image URL").option("--port <port>", "Container port").option("--cpu <tier>", "CPU tier").option("--memory <mb>", "Memory in MB").option("--region <region>", "Fly.io region").option("--env <json>", "Environment variables as JSON object").action(async (id, opts, cmd) => {
+    const { json } = getRootOpts(cmd);
+    try {
+      await requireAuth();
+      const body = {};
+      if (opts.image) body.imageUrl = opts.image;
+      if (opts.port) {
+        if (!Number.isFinite(Number(opts.port))) {
+          throw new CLIError("Invalid value for --port: must be a number");
+        }
+        body.port = Number(opts.port);
+      }
+      if (opts.cpu) body.cpu = opts.cpu;
+      if (opts.memory) {
+        if (!Number.isFinite(Number(opts.memory))) {
+          throw new CLIError("Invalid value for --memory: must be a number");
+        }
+        body.memory = Number(opts.memory);
+      }
+      if (opts.region) body.region = opts.region;
+      if (opts.env) {
+        try {
+          body.envVars = JSON.parse(opts.env);
+        } catch {
+          throw new CLIError("Invalid JSON for --env");
+        }
+      }
+      if (Object.keys(body).length === 0) {
+        throw new CLIError("No update fields provided. Use --image, --port, --cpu, --memory, --region, or --env.");
+      }
+      const res = await ossFetch(`/api/compute/services/${encodeURIComponent(id)}`, {
+        method: "PATCH",
+        body: JSON.stringify(body)
+      });
+      const service = await res.json();
+      if (json) {
+        outputJson(service);
+      } else {
+        outputSuccess(`Service "${service.name}" updated [${service.status}]`);
+      }
+      await reportCliUsage("cli.compute.update", true);
+    } catch (err) {
+      await reportCliUsage("cli.compute.update", false);
+      handleError(err, json);
+    }
+  });
+}
+
+// src/commands/compute/delete.ts
+function registerComputeDeleteCommand(computeCmd2) {
+  computeCmd2.command("delete <id>").description("Delete a compute service and its Fly.io resources").action(async (id, _opts, cmd) => {
+    const { json } = getRootOpts(cmd);
+    try {
+      await requireAuth();
+      const res = await ossFetch(`/api/compute/services/${encodeURIComponent(id)}`, {
+        method: "DELETE"
+      });
+      const data = await res.json();
+      if (json) {
+        outputJson(data);
+      } else {
+        outputSuccess("Service deleted.");
+      }
+      await reportCliUsage("cli.compute.delete", true);
+    } catch (err) {
+      await reportCliUsage("cli.compute.delete", false);
+      handleError(err, json);
+    }
+  });
+}
+
+// src/commands/compute/start.ts
+function registerComputeStartCommand(computeCmd2) {
+  computeCmd2.command("start <id>").description("Start a stopped compute service").action(async (id, _opts, cmd) => {
+    const { json } = getRootOpts(cmd);
+    try {
+      await requireAuth();
+      const res = await ossFetch(`/api/compute/services/${encodeURIComponent(id)}/start`, {
+        method: "POST"
+      });
+      const service = await res.json();
+      if (json) {
+        outputJson(service);
+      } else {
+        outputSuccess(`Service "${service.name}" started [${service.status}]`);
+        if (service.endpointUrl) {
+          console.log(`  Endpoint: ${service.endpointUrl}`);
+        }
+      }
+      await reportCliUsage("cli.compute.start", true);
+    } catch (err) {
+      await reportCliUsage("cli.compute.start", false);
+      handleError(err, json);
+    }
+  });
+}
+
+// src/commands/compute/stop.ts
+function registerComputeStopCommand(computeCmd2) {
+  computeCmd2.command("stop <id>").description("Stop a running compute service").action(async (id, _opts, cmd) => {
+    const { json } = getRootOpts(cmd);
+    try {
+      await requireAuth();
+      const res = await ossFetch(`/api/compute/services/${encodeURIComponent(id)}/stop`, {
+        method: "POST"
+      });
+      const service = await res.json();
+      if (json) {
+        outputJson(service);
+      } else {
+        outputSuccess(`Service "${service.name}" stopped.`);
+      }
+      await reportCliUsage("cli.compute.stop", true);
+    } catch (err) {
+      await reportCliUsage("cli.compute.stop", false);
+      handleError(err, json);
+    }
+  });
+}
+
+// src/commands/compute/logs.ts
+function registerComputeLogsCommand(computeCmd2) {
+  computeCmd2.command("logs <id>").description("Get compute service logs (machine events)").option("--limit <n>", "Max number of log entries", "50").action(async (id, opts, cmd) => {
+    const { json } = getRootOpts(cmd);
+    try {
+      await requireAuth();
+      const limit = Math.max(1, Math.min(Number(opts.limit) || 50, 1e3));
+      const res = await ossFetch(
+        `/api/compute/services/${encodeURIComponent(id)}/logs?limit=${limit}`
+      );
+      const logs = await res.json();
+      if (json) {
+        outputJson(logs);
+      } else {
+        if (!Array.isArray(logs) || logs.length === 0) {
+          console.log("No logs found.");
+          await reportCliUsage("cli.compute.logs", true);
+          return;
+        }
+        for (const entry of logs) {
+          const ts = new Date(entry.timestamp).toISOString();
+          console.log(`${ts}  ${entry.message}`);
+        }
+      }
+      await reportCliUsage("cli.compute.logs", true);
+    } catch (err) {
+      await reportCliUsage("cli.compute.logs", false);
+      handleError(err, json);
+    }
+  });
+}
+
+// src/commands/compute/deploy.ts
+import { existsSync as existsSync5, readFileSync as readFileSync6, writeFileSync as writeFileSync4, unlinkSync as unlinkSync2, renameSync } from "fs";
+import { join as join7 } from "path";
+import { execSync, spawn } from "child_process";
+function parseFlyToml(dir) {
+  const tomlPath = join7(dir, "fly.toml");
+  if (!existsSync5(tomlPath)) return {};
+  const content = readFileSync6(tomlPath, "utf-8");
+  const config = {};
+  const portMatch = content.match(/internal_port\s*=\s*(\d+)/);
+  if (portMatch) config.internalPort = Number(portMatch[1]);
+  const regionMatch = content.match(/primary_region\s*=\s*'([^']+)'/);
+  if (regionMatch) config.region = regionMatch[1];
+  const memoryMatch = content.match(/memory\s*=\s*'(\d+)/);
+  if (memoryMatch) config.memory = memoryMatch[1];
+  const cpuKindMatch = content.match(/cpu_kind\s*=\s*'([^']+)'/);
+  if (cpuKindMatch) config.cpuKind = cpuKindMatch[1];
+  const cpusMatch = content.match(/cpus\s*=\s*(\d+)/);
+  if (cpusMatch) config.cpus = Number(cpusMatch[1]);
+  return config;
+}
+function memoryToCpuTier(cpuKind, cpus) {
+  if (!cpuKind) return void 0;
+  const kind = cpuKind === "performance" ? "performance" : "shared";
+  const count = cpus ?? 1;
+  return `${kind}-${count}x`;
+}
+function generateFlyToml(appName, opts) {
+  const cpuParts = opts.cpu.split("-");
+  const cpuKind = cpuParts[0] ?? "shared";
+  const cpuCount = parseInt(cpuParts[1] ?? "1", 10);
+  return `# Auto-generated by InsForge CLI
+app = '${appName}'
+primary_region = '${opts.region}'
+
+[build]
+  dockerfile = 'Dockerfile'
+
+[http_service]
+  internal_port = ${opts.port}
+  force_https = true
+  auto_stop_machines = 'stop'
+  auto_start_machines = true
+  min_machines_running = 0
+
+[[vm]]
+  memory = '${opts.memory}mb'
+  cpu_kind = '${cpuKind}'
+  cpus = ${cpuCount}
+`;
+}
+function checkFlyctl() {
+  try {
+    execSync("flyctl version", { stdio: "pipe" });
+  } catch {
+    throw new CLIError(
+      "flyctl is not installed.\nInstall it with: curl -L https://fly.io/install.sh | sh\nOr: brew install flyctl"
+    );
+  }
+}
+function getFlyToken() {
+  const token = process.env.FLY_API_TOKEN;
+  if (!token) {
+    throw new CLIError(
+      "FLY_API_TOKEN environment variable is required for compute deploy.\nSet it with: export FLY_API_TOKEN=<your-fly-token>"
+    );
+  }
+  return token;
+}
+function registerComputeDeployCommand(computeCmd2) {
+  computeCmd2.command("deploy [directory]").description("Build and deploy a Dockerfile as a compute service").requiredOption("--name <name>", "Service name").option("--port <port>", "Container port").option("--cpu <tier>", "CPU tier (shared-1x, shared-2x, performance-1x, etc.)").option("--memory <mb>", "Memory in MB (256, 512, 1024, 2048, 4096, 8192)").option("--region <region>", "Fly.io region").option("--env <json>", "Environment variables as JSON object").action(async (directory, opts, cmd) => {
+    const { json } = getRootOpts(cmd);
+    try {
+      await requireAuth();
+      checkFlyctl();
+      const flyToken = getFlyToken();
+      const dir = directory ?? process.cwd();
+      const dockerfilePath = join7(dir, "Dockerfile");
+      if (!existsSync5(dockerfilePath)) {
+        throw new CLIError(`No Dockerfile found in ${dir}`);
+      }
+      const flyTomlDefaults = parseFlyToml(dir);
+      const port = Number(opts.port) || flyTomlDefaults.internalPort || 8080;
+      const cpu = opts.cpu || memoryToCpuTier(flyTomlDefaults.cpuKind, flyTomlDefaults.cpus) || "shared-1x";
+      const memory = Number(opts.memory) || Number(flyTomlDefaults.memory) || 512;
+      const region = opts.region || flyTomlDefaults.region || "iad";
+      let envVars;
+      if (opts.env) {
+        try {
+          envVars = JSON.parse(opts.env);
+        } catch {
+          throw new CLIError("Invalid JSON for --env");
+        }
+      }
+      if (!json) outputInfo(`Checking for existing service "${opts.name}"...`);
+      const listRes = await ossFetch("/api/compute/services");
+      const services = await listRes.json();
+      const existing = services.find((s) => s.name === opts.name);
+      let serviceId;
+      let flyAppId;
+      if (existing) {
+        serviceId = existing.id;
+        flyAppId = existing.flyAppId;
+        if (!json) outputInfo(`Found existing service, redeploying...`);
+      } else {
+        if (!json) outputInfo(`Creating service "${opts.name}"...`);
+        const body = {
+          name: opts.name,
+          imageUrl: "dockerfile",
+          port,
+          cpu,
+          memory,
+          region
+        };
+        if (envVars) body.envVars = envVars;
+        const deployRes = await ossFetch("/api/compute/services/deploy", {
+          method: "POST",
+          body: JSON.stringify(body)
+        });
+        const service = await deployRes.json();
+        serviceId = service.id;
+        flyAppId = service.flyAppId;
+      }
+      const existingTomlPath = join7(dir, "fly.toml");
+      const backupTomlPath = join7(dir, "fly.toml.insforge-backup");
+      let hadExistingToml = false;
+      if (existsSync5(existingTomlPath)) {
+        hadExistingToml = true;
+        renameSync(existingTomlPath, backupTomlPath);
+      }
+      const tomlContent = generateFlyToml(flyAppId, { port, memory, cpu, region });
+      writeFileSync4(existingTomlPath, tomlContent);
+      try {
+        if (!json) outputInfo("Building and deploying (this may take a few minutes)...");
+        await new Promise((resolve2, reject) => {
+          const child = spawn(
+            "flyctl",
+            ["deploy", "--remote-only", "--app", flyAppId, "--access-token", flyToken, "--yes"],
+            { cwd: dir, stdio: json ? "pipe" : "inherit" }
+          );
+          child.on("close", (code) => {
+            if (code === 0) resolve2();
+            else reject(new CLIError(`flyctl deploy failed with exit code ${code}`));
+          });
+          child.on("error", (err) => reject(new CLIError(`flyctl deploy error: ${err.message}`)));
+        });
+        if (!json) outputInfo("Syncing deployment info...");
+        const syncRes = await ossFetch(
+          `/api/compute/services/${encodeURIComponent(serviceId)}/sync`,
+          { method: "PATCH" }
+        );
+        const synced = await syncRes.json();
+        if (json) {
+          outputJson(synced);
+        } else {
+          outputSuccess(`Service "${synced.name}" deployed [${synced.status}]`);
+          if (synced.endpointUrl) {
+            console.log(`  Endpoint: ${synced.endpointUrl}`);
+          }
+        }
+        await reportCliUsage("cli.compute.deploy", true);
+      } finally {
+        try {
+          unlinkSync2(existingTomlPath);
+          if (hadExistingToml) {
+            renameSync(backupTomlPath, existingTomlPath);
+          }
+        } catch {
+        }
+      }
+    } catch (err) {
+      await reportCliUsage("cli.compute.deploy", false);
+      handleError(err, json);
+    }
+  });
+}
+
 // src/commands/logs.ts
 var VALID_SOURCES = ["insforge.logs", "postgREST.logs", "postgres.logs", "function.logs", "function-deploy.logs"];
 var SOURCE_LOOKUP = new Map(VALID_SOURCES.map((s) => [s.toLowerCase(), s]));
@@ -4019,7 +4477,7 @@ function formatBytesCompact(bytes) {
 
 // src/index.ts
 var __dirname = dirname(fileURLToPath(import.meta.url));
-var pkg = JSON.parse(readFileSync6(join7(__dirname, "../package.json"), "utf-8"));
+var pkg = JSON.parse(readFileSync7(join8(__dirname, "../package.json"), "utf-8"));
 var INSFORGE_LOGO = `
 \u2588\u2588\u2557\u2588\u2588\u2588\u2557   \u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557
 \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D \u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D
@@ -4087,6 +4545,16 @@ registerLogsCommand(program);
 registerMetadataCommand(program);
 var diagnoseCmd = program.command("diagnose");
 registerDiagnoseCommands(diagnoseCmd);
+var computeCmd = program.command("compute").description("Manage compute services (Docker containers on Fly.io)");
+registerComputeListCommand(computeCmd);
+registerComputeGetCommand(computeCmd);
+registerComputeCreateCommand(computeCmd);
+registerComputeDeployCommand(computeCmd);
+registerComputeUpdateCommand(computeCmd);
+registerComputeDeleteCommand(computeCmd);
+registerComputeStartCommand(computeCmd);
+registerComputeStopCommand(computeCmd);
+registerComputeLogsCommand(computeCmd);
 var schedulesCmd = program.command("schedules").description("Manage scheduled tasks (cron jobs)");
 registerSchedulesListCommand(schedulesCmd);
 registerSchedulesGetCommand(schedulesCmd);