@jrc03c/gt-cli 0.1.1

package/README.md

@@ -0,0 +1,112 @@
+# gt-cli
+
+A TypeScript CLI for the [GuidedTrack](https://guidedtrack.com) web API.
+
+## Install
+
+Requires Node.js >= 20 and [pnpm](https://pnpm.io/).
+
+```bash
+pnpm install
+pnpm build
+pnpm link --global  # makes `gt` available globally
+```
+
+## Authentication
+
+Auth is resolved in this order:
+
+1. **Environment variables**: `GT_EMAIL` and `GT_PASSWORD`
+2. **Config file**: `email` and `password` fields in `gt.config.json`
+3. **Interactive prompt**: falls back to prompting if neither is set
+
+## Environment
+
+Set `GT_ENV` to target different GuidedTrack environments:
+
+| Value | Host |
+|-------|------|
+| `development` | `https://localhost:3000` |
+| `stage` | `https://guidedtrack-stage.herokuapp.com` |
+| `production` (default) | `https://www.guidedtrack.com` |
+
+## Commands
+
+### Project workflow
+
+```bash
+gt init                          # Create gt.config.json by scanning for program files
+gt config                        # Print current project configuration
+gt push                          # Upload all local program files to the server
+gt push --only <name>            # Push a single program
+gt push --build                  # Push and build
+gt pull                          # Download all program sources from the server
+gt pull --only <name>            # Pull a single program
+gt create [names...]             # Create new programs on the server
+gt build                         # Compile programs and report errors
+gt compare [args...]             # Compare programs using gt-compare
+```
+
+### Program management
+
+```bash
+gt program list                  # List all programs
+gt program find <query>          # Search programs by name
+gt program get <name>            # Fetch program metadata (JSON)
+gt program source <name>         # Fetch program source code
+gt program build <name>          # Build a specific program
+gt program delete <name>         # Delete a program (with confirmation)
+gt program delete <name> -y      # Delete without confirmation
+```
+
+### Program data
+
+```bash
+gt program data <name>           # Download program data as CSV (stdout)
+gt program csv <name>            # Alias for `program data`
+gt program data <name> -o f.csv  # Save to file
+```
+
+### Browser shortcuts
+
+```bash
+gt program view <name>           # Open program edit page
+gt program preview <name>        # Open program preview
+gt program run <name>            # Open program run page
+```
+
+### Generic API access
+
+```bash
+gt request <path>                             # GET any API endpoint
+gt request <path> -X POST -d '{"key":"val"}'  # POST with JSON body
+gt request <path> -H "X-Custom:value"         # Add custom headers
+```
+
+## Configuration
+
+`gt init` creates a `gt.config.json` in the current directory:
+
+```json
+{
+  "programs": {
+    "my-program": {
+      "id": 12345,
+      "key": "abc1234"
+    }
+  }
+}
+```
+
+This file is gitignored. It maps local program file names to their server-side IDs and keys.
+
+## Development
+
+```bash
+pnpm dev [command] [args]   # Run via tsx (no build step)
+pnpm build                  # Bundle to dist/
+pnpm test                   # Run tests
+pnpm test:watch             # Watch mode
+pnpm lint                   # ESLint
+pnpm format                 # Prettier
+```

package/dist/index.js

@@ -0,0 +1,876 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/build.ts
+import { readFile as readFile2 } from "fs/promises";
+import { resolve as resolve2 } from "path";
+
+// src/types.ts
+var ENVIRONMENT_HOSTS = {
+  development: "https://localhost:3000",
+  stage: "https://guidedtrack-stage.herokuapp.com",
+  production: "https://www.guidedtrack.com"
+};
+
+// src/lib/api.ts
+function buildAuthHeader(credentials) {
+  const encoded = Buffer.from(
+    `${credentials.email}:${credentials.password}`
+  ).toString("base64");
+  return `Basic ${encoded}`;
+}
+async function apiRequest(path, options) {
+  const env = options.environment ?? getEnvironment();
+  const host = ENVIRONMENT_HOSTS[env];
+  const url = `${host}${path}`;
+  const headers = {
+    Authorization: buildAuthHeader(options.credentials),
+    ...options.headers
+  };
+  if (options.body) {
+    headers["Content-Type"] = "application/json";
+  }
+  const response = await fetch(url, {
+    method: options.method ?? "GET",
+    headers,
+    body: options.body ? JSON.stringify(options.body) : void 0
+  });
+  if (!response.ok) {
+    throw new Error(
+      `API request failed: ${response.status} ${response.statusText}`
+    );
+  }
+  return response;
+}
+async function findProgramByTitle(title, credentials, environment) {
+  const query = encodeURIComponent(title);
+  const response = await apiRequest(`/programs.json?query=${query}`, {
+    credentials,
+    environment
+  });
+  const programs = await response.json();
+  return programs.find((p) => p.name === title) ?? null;
+}
+async function getProgram(id, credentials, environment) {
+  try {
+    const response = await apiRequest(`/programs/${id}.json`, {
+      credentials,
+      environment
+    });
+    return await response.json();
+  } catch {
+    return null;
+  }
+}
+async function findProgramByKey(key, credentials, environment) {
+  const response = await apiRequest("/programs.json", {
+    credentials,
+    environment
+  });
+  const programs = await response.json();
+  return programs.find((p) => p.key === key) ?? null;
+}
+async function listPrograms(credentials, environment) {
+  const response = await apiRequest("/programs.json", {
+    credentials,
+    environment
+  });
+  return await response.json();
+}
+async function fetchProgramSource(programId, credentials, environment) {
+  const env = environment ?? getEnvironment();
+  const host = ENVIRONMENT_HOSTS[env];
+  const response = await fetch(`${host}/programs/${programId}/edit`, {
+    headers: { Authorization: buildAuthHeader(credentials) }
+  });
+  if (!response.ok) {
+    throw new Error(
+      `Failed to fetch program source: ${response.status} ${response.statusText}`
+    );
+  }
+  const html = await response.text();
+  const match = html.match(
+    /<textarea[^>]*name="contents"[^>]*>([\s\S]*?)<\/textarea>/
+  );
+  if (!match) {
+    throw new Error("Could not extract program source from edit page");
+  }
+  return match[1].replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'");
+}
+function getEnvironment() {
+  const env = process.env.GT_ENV ?? "production";
+  if (env !== "development" && env !== "stage" && env !== "production") {
+    throw new Error(
+      `Invalid GT_ENV: "${env}". Must be development, stage, or production.`
+    );
+  }
+  return env;
+}
+
+// src/lib/auth.ts
+import { createInterface } from "readline";
+
+// src/lib/config.ts
+import { readFile, writeFile } from "fs/promises";
+import { resolve } from "path";
+var CONFIG_FILENAME = "gt.config.json";
+async function loadConfig(dir) {
+  const configPath = resolve(dir ?? process.cwd(), CONFIG_FILENAME);
+  try {
+    const raw = await readFile(configPath, "utf-8");
+    return JSON.parse(raw);
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      return {};
+    }
+    throw new Error(`Failed to read ${CONFIG_FILENAME}: ${err}`);
+  }
+}
+async function saveConfig(config, dir) {
+  const configPath = resolve(dir ?? process.cwd(), CONFIG_FILENAME);
+  await writeFile(configPath, JSON.stringify(config, null, 2) + "\n");
+}
+
+// src/lib/auth.ts
+function prompt(question) {
+  const rl2 = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve7) => {
+    rl2.question(question, (answer) => {
+      rl2.close();
+      resolve7(answer);
+    });
+  });
+}
+function promptSecret(question) {
+  const rl2 = createInterface({ input: process.stdin, output: process.stdout });
+  const originalWrite = process.stdout.write.bind(process.stdout);
+  let muted = false;
+  process.stdout.write = ((...args) => {
+    if (muted) {
+      return true;
+    }
+    return originalWrite(...args);
+  });
+  return new Promise((resolve7) => {
+    rl2.question(question, (answer) => {
+      muted = false;
+      process.stdout.write = originalWrite;
+      originalWrite("\n");
+      rl2.close();
+      resolve7(answer);
+    });
+    muted = true;
+  });
+}
+async function promptCredentials() {
+  const email = await prompt("GT email: ");
+  const password = await promptSecret("GT password: ");
+  return { email, password };
+}
+async function resolveCredentials() {
+  const email = process.env.GT_EMAIL;
+  const password = process.env.GT_PASSWORD;
+  if (email && password) {
+    return { email, password };
+  }
+  const config = await loadConfig();
+  if (config.email && config.password) {
+    return { email: config.email, password: config.password };
+  }
+  if (process.stdin.isTTY) {
+    return promptCredentials();
+  }
+  throw new Error(
+    "No credentials found. Provide credentials via:\n  - GT_EMAIL and GT_PASSWORD environment variables\n  - email and password fields in gt.config.json\n  - Run in a terminal for interactive prompt"
+  );
+}
+
+// src/lib/jobs.ts
+var DEFAULT_POLL_INTERVAL_MS = 3e3;
+async function pollJob(jobId, credentials, options) {
+  const interval = options?.intervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+  while (true) {
+    const response = await apiRequest(`/delayed_jobs/${jobId}`, {
+      credentials,
+      environment: options?.environment
+    });
+    const job = await response.json();
+    if (job.status !== "running") {
+      return job;
+    }
+    await new Promise((resolve7) => setTimeout(resolve7, interval));
+  }
+}
+
+// src/lib/build.ts
+async function getEmbedInfo(key, credentials, environment) {
+  const response = await apiRequest(`/programs/${key}/embed`, {
+    credentials,
+    environment
+  });
+  return await response.json();
+}
+async function getRunContents(runId, accessKey, credentials, environment) {
+  const response = await apiRequest(`/runs/${runId}/contents`, {
+    credentials,
+    environment,
+    headers: { "X-GuidedTrack-Access-Key": accessKey }
+  });
+  return response.json();
+}
+function extractErrors(contents) {
+  if (!Array.isArray(contents)) {
+    if (contents && typeof contents === "object") {
+      const errors2 = [];
+      for (const value of Object.values(
+        contents
+      )) {
+        if (value && typeof value === "object" && "metadata" in value) {
+          const metadata = value.metadata;
+          if (metadata?.errors) {
+            errors2.push(...metadata.errors);
+          }
+        }
+      }
+      return errors2;
+    }
+    return [];
+  }
+  const errors = [];
+  for (const item of contents) {
+    if (item && typeof item === "object" && "metadata" in item) {
+      const metadata = item.metadata;
+      if (metadata?.errors) {
+        errors.push(...metadata.errors);
+      }
+    }
+  }
+  return errors;
+}
+async function buildProgram(name, key, credentials, environment) {
+  console.log(`>> Building project "${name}" (key: ${key})`);
+  const embed = await getEmbedInfo(key, credentials, environment);
+  const contents = await getRunContents(
+    embed.run_id,
+    embed.access_key,
+    credentials,
+    environment
+  );
+  const jobId = contents && typeof contents === "object" && !Array.isArray(contents) ? contents.job : null;
+  if (jobId && typeof jobId === "number") {
+    process.stdout.write(`>>>> Waiting for new build (job: ${jobId})... `);
+    await pollJob(jobId, credentials, { environment });
+    console.log("done");
+  } else {
+    console.log(">>>> No changes to build");
+  }
+  const result = await getRunContents(
+    embed.run_id,
+    embed.access_key,
+    credentials,
+    environment
+  );
+  const errors = extractErrors(result);
+  if (errors.length === 0) {
+    console.log(">>>> No errors");
+  } else {
+    console.log(">>>> Found compilation errors:");
+    console.log(errors.join("\n"));
+  }
+}
+
+// src/commands/build.ts
+var PROJECTS_FILENAME = ".gt_projects";
+function registerBuild(program2) {
+  program2.command("build").description("Compile programs and report errors").action(async () => {
+    const credentials = await resolveCredentials();
+    const environment = getEnvironment();
+    const projects = await loadProjects();
+    if (!projects) {
+      console.log(`No ${PROJECTS_FILENAME} file, nothing to build`);
+      return;
+    }
+    for (const project of projects) {
+      const found = await findProgramByTitle(project, credentials, environment);
+      if (!found) {
+        console.error(`>> Program "${project}" not found, skipping...`);
+        continue;
+      }
+      await buildProgram(project, found.key, credentials, environment);
+    }
+  });
+}
+async function loadProjects() {
+  try {
+    const raw = await readFile2(
+      resolve2(process.cwd(), PROJECTS_FILENAME),
+      "utf-8"
+    );
+    return raw.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+  } catch {
+    return null;
+  }
+}
+
+// src/commands/compare.ts
+import { execFileSync } from "child_process";
+import { dirname, resolve as resolve3 } from "path";
+function registerCompare(program2) {
+  program2.command("compare").description("Compare programs using gt-compare").allowUnknownOption().argument("[args...]", "Arguments to pass to gt-compare").action((args) => {
+    const gtPath = process.env.GT_COMPARE_PATH ?? findGtCompare();
+    if (!gtPath) {
+      console.error(
+        "Could not find gt-compare. Set GT_COMPARE_PATH to the gt-compare directory."
+      );
+      process.exit(1);
+    }
+    try {
+      execFileSync("./gt-compare", args, {
+        cwd: gtPath,
+        stdio: "inherit"
+      });
+    } catch {
+      process.exit(1);
+    }
+  });
+}
+function findGtCompare() {
+  try {
+    const gtBin = execFileSync("which", ["gt"], { encoding: "utf-8" }).trim();
+    return resolve3(dirname(gtBin), "gt-compare");
+  } catch {
+    return null;
+  }
+}
+
+// src/commands/config.ts
+function registerConfig(program2) {
+  program2.command("config").description("Print current project configuration").action(async () => {
+    const config = await loadConfig();
+    console.log(JSON.stringify(config, null, 2));
+  });
+}
+
+// src/lib/files.ts
+import { readdir } from "fs/promises";
+import { join, relative } from "path";
+async function getLocalGtFiles(dir) {
+  const files = [];
+  await scanDir(dir, dir, files);
+  return files.sort();
+}
+async function scanDir(root, current, results) {
+  const entries = await readdir(current, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join(current, entry.name);
+    if (entry.isDirectory() && entry.name !== "node_modules") {
+      await scanDir(root, fullPath, results);
+    } else if (entry.isFile() && entry.name.endsWith(".gt")) {
+      results.push(relative(root, fullPath));
+    }
+  }
+}
+
+// src/commands/create.ts
+function registerCreate(program2) {
+  program2.command("create").description("Create new programs on the server").argument(
+    "[names...]",
+    "Program names to create (defaults to all .gt files in cwd)"
+  ).action(async (names) => {
+    const credentials = await resolveCredentials();
+    const environment = getEnvironment();
+    const filenames = names.length > 0 ? names : await getLocalGtFiles(process.cwd());
+    if (filenames.length === 0) {
+      console.error("No .gt files to create.");
+      process.exit(1);
+    }
+    console.log(`Creating programs in ${environment}...`);
+    for (const filename of filenames) {
+      process.stdout.write(`>> Creating "${filename}"... `);
+      try {
+        const response = await apiRequest("/programs", {
+          method: "POST",
+          credentials,
+          environment,
+          body: { name: filename }
+        });
+        const data = await response.json();
+        if (data.job_id) {
+          console.log("done");
+        } else {
+          console.error("failed");
+          console.error(`${JSON.stringify(data)} -- skipping`);
+        }
+      } catch (e) {
+        console.error("failed");
+        console.error(e.message);
+        process.exit(1);
+      }
+    }
+  });
+}
+
+// src/lib/prompt.ts
+import { createInterface as createInterface2 } from "readline";
+var rl = () => createInterface2({ input: process.stdin, output: process.stdout });
+async function ask(question) {
+  const iface = rl();
+  return new Promise((resolve7) => {
+    iface.question(question, (answer) => {
+      iface.close();
+      resolve7(answer.trim());
+    });
+  });
+}
+async function confirm(question) {
+  const answer = await ask(`${question} (y/N) `);
+  return answer.toLowerCase() === "y" || answer.toLowerCase() === "yes";
+}
+async function choose(question, options) {
+  console.log(question);
+  for (let i = 0; i < options.length; i++) {
+    console.log(`  ${i + 1}. ${options[i]}`);
+  }
+  const answer = await ask("Enter choice: ");
+  const choice = parseInt(answer, 10);
+  if (isNaN(choice) || choice < 1 || choice > options.length) {
+    console.log("Invalid choice.");
+    return -1;
+  }
+  return choice - 1;
+}
+
+// src/commands/init.ts
+function registerInit(program2) {
+  program2.command("init").description("Create gt.config.json by linking local .gt files to programs").action(async () => {
+    const credentials = await resolveCredentials();
+    const environment = getEnvironment();
+    const existing = await loadConfig();
+    const programs = existing.programs ?? {};
+    const files = await getLocalGtFiles(process.cwd());
+    if (files.length === 0) {
+      console.log("No .gt files found.");
+      return;
+    }
+    const linkedFiles = new Set(Object.values(programs).map((p) => p.file));
+    for (const file of files) {
+      if (linkedFiles.has(file)) {
+        console.log(`
+"${file}" is already linked, skipping.`);
+        continue;
+      }
+      console.log(`
+Found "${file}"`);
+      const shouldLink = await confirm(
+        "Do you want to link it to a program on guidedtrack.com?"
+      );
+      if (!shouldLink) continue;
+      const idType = await choose(
+        "Which identifier do you want to use to find the program?",
+        [
+          `The program's title (e.g., "My Cool Program")`,
+          "The program's ID (e.g., 12345)",
+          `The program's key (e.g., "abc1234")`
+        ]
+      );
+      if (idType === -1) continue;
+      let found = null;
+      if (idType === 0) {
+        const title = await ask("Enter program title: ");
+        if (!title) continue;
+        process.stdout.write(`Looking up "${title}" in ${environment}... `);
+        found = await findProgramByTitle(title, credentials, environment);
+      } else if (idType === 1) {
+        const idStr = await ask("Enter program ID: ");
+        const id = parseInt(idStr, 10);
+        if (isNaN(id)) {
+          console.log("Invalid ID.");
+          continue;
+        }
+        process.stdout.write(
+          `Looking up program ${id} in ${environment}... `
+        );
+        found = await getProgram(id, credentials, environment);
+      } else {
+        const key = await ask("Enter program key: ");
+        if (!key) continue;
+        process.stdout.write(
+          `Looking up program "${key}" in ${environment}... `
+        );
+        found = await findProgramByKey(key, credentials, environment);
+      }
+      if (!found) {
+        console.log("not found.");
+        continue;
+      }
+      console.log(`found! ("${found.name}")`);
+      if (programs[found.key]) {
+        console.log(
+          `Program "${found.name}" is already linked to "${programs[found.key].file}", skipping.`
+        );
+        continue;
+      }
+      programs[found.key] = { file, id: found.id };
+      linkedFiles.add(file);
+      console.log(`Linked "${file}" \u2192 "${found.name}" (key: ${found.key})`);
+    }
+    const config = { ...existing, programs };
+    await saveConfig(config);
+    console.log(`
+Wrote ${CONFIG_FILENAME}`);
+  });
+}
+
+// src/commands/program.ts
+import { exec } from "child_process";
+import { writeFile as writeFile2 } from "fs/promises";
+import { resolve as resolve4 } from "path";
+import { createInterface as createInterface3 } from "readline";
+function registerProgram(parent) {
+  const program2 = parent.command("program").description("Manage programs on the server");
+  program2.command("list").description("List all programs").action(async () => {
+    const credentials = await resolveCredentials();
+    const environment = getEnvironment();
+    const programs = await listPrograms(credentials, environment);
+    if (programs.length === 0) {
+      console.log("No programs found.");
+      return;
+    }
+    for (const p of programs) {
+      console.log(`${p.id}	${p.key}	${p.name}`);
+    }
+  });
+  program2.command("get").description("Fetch program metadata").argument("<name>", "Program name").action(async (name) => {
+    const credentials = await resolveCredentials();
+    const environment = getEnvironment();
+    const found = await findProgramByTitle(name, credentials, environment);
+    if (!found) {
+      console.error(`Program "${name}" not found.`);
+      process.exit(1);
+    }
+    console.log(JSON.stringify(found, null, 2));
+  });
+  program2.command("source").description("Fetch program source code").argument("<name>", "Program name").action(async (name) => {
+    const credentials = await resolveCredentials();
+    const environment = getEnvironment();
+    const found = await findProgramByTitle(name, credentials, environment);
+    if (!found) {
+      console.error(`Program "${name}" not found.`);
+      process.exit(1);
+    }
+    const source = await fetchProgramSource(
+      found.id,
+      credentials,
+      environment
+    );
+    process.stdout.write(source);
+  });
+  program2.command("find").description("Search programs by name").argument("<query>", "Search query").action(async (query) => {
+    const credentials = await resolveCredentials();
+    const environment = getEnvironment();
+    const encoded = encodeURIComponent(query);
+    const response = await apiRequest(`/programs.json?query=${encoded}`, {
+      credentials,
+      environment
+    });
+    const programs = await response.json();
+    if (programs.length === 0) {
+      console.log("No programs found.");
+      return;
+    }
+    for (const p of programs) {
+      console.log(`${p.id}	${p.key}	${p.name}`);
+    }
+  });
+  program2.command("delete").description("Delete a program (with confirmation)").argument("<name>", "Program name").option("-y, --yes", "Skip confirmation prompt").action(async (name, options) => {
+    const credentials = await resolveCredentials();
+    const environment = getEnvironment();
+    const found = await findProgramByTitle(name, credentials, environment);
+    if (!found) {
+      console.error(`Program "${name}" not found.`);
+      process.exit(1);
+    }
+    if (!options.yes) {
+      const confirmed = await confirm2(
+        `Delete "${name}" (id: ${found.id})? This cannot be undone. [y/N] `
+      );
+      if (!confirmed) {
+        console.log("Aborted.");
+        return;
+      }
+    }
+    await apiRequest(`/programs/${found.id}.json`, {
+      method: "DELETE",
+      credentials,
+      environment
+    });
+    console.log(`Deleted "${name}" (id: ${found.id})`);
+  });
+  program2.command("build").description("Build a specific program").argument("<name>", "Program name").action(async (name) => {
+    const credentials = await resolveCredentials();
+    const environment = getEnvironment();
+    const found = await findProgramByTitle(name, credentials, environment);
+    if (!found) {
+      console.error(`Program "${name}" not found.`);
+      process.exit(1);
+    }
+    console.log(`Building "${name}" (key: ${found.key})...`);
+    const embed = await getEmbedInfo(found.key, credentials, environment);
+    const contents = await getRunContents(
+      embed.run_id,
+      embed.access_key,
+      credentials,
+      environment
+    );
+    const jobId = contents && typeof contents === "object" && !Array.isArray(contents) ? contents.job : null;
+    if (jobId && typeof jobId === "number") {
+      process.stdout.write(`Waiting for build (job: ${jobId})... `);
+      await pollJob(jobId, credentials, { environment });
+      console.log("done");
+    } else {
+      console.log("No changes to build");
+    }
+    const result = await getRunContents(
+      embed.run_id,
+      embed.access_key,
+      credentials,
+      environment
+    );
+    const errors = extractErrors(result);
+    if (errors.length === 0) {
+      console.log("No errors");
+    } else {
+      console.log("Found compilation errors:");
+      console.log(errors.join("\n"));
+    }
+  });
+  program2.command("view").description("Open program edit page in browser").argument("<name>", "Program name").action(async (name) => {
+    const credentials = await resolveCredentials();
+    const environment = getEnvironment();
+    const found = await findProgramByTitle(name, credentials, environment);
+    if (!found) {
+      console.error(`Program "${name}" not found.`);
+      process.exit(1);
+    }
+    const url = `${ENVIRONMENT_HOSTS[environment]}/programs/${found.id}/edit`;
+    openBrowser(url);
+  });
+  program2.command("preview").description("Open program preview in browser").argument("<name>", "Program name").action(async (name) => {
+    const credentials = await resolveCredentials();
+    const environment = getEnvironment();
+    const found = await findProgramByTitle(name, credentials, environment);
+    if (!found) {
+      console.error(`Program "${name}" not found.`);
+      process.exit(1);
+    }
+    const url = `${ENVIRONMENT_HOSTS[environment]}/programs/${found.key}/preview`;
+    openBrowser(url);
+  });
+  program2.command("run").description("Open program run page in browser").argument("<name>", "Program name").action(async (name) => {
+    const credentials = await resolveCredentials();
+    const environment = getEnvironment();
+    const found = await findProgramByTitle(name, credentials, environment);
+    if (!found) {
+      console.error(`Program "${name}" not found.`);
+      process.exit(1);
+    }
+    const url = `${ENVIRONMENT_HOSTS[environment]}/programs/${found.key}/run`;
+    openBrowser(url);
+  });
+  program2.command("data").alias("csv").description("Download program data as CSV").argument("<name>", "Program name").option("-o, --output <file>", "Save to file instead of stdout").action(async (name, options) => {
+    const credentials = await resolveCredentials();
+    const environment = getEnvironment();
+    const found = await findProgramByTitle(name, credentials, environment);
+    if (!found) {
+      console.error(`Program "${name}" not found.`);
+      process.exit(1);
+    }
+    const response = await apiRequest(`/programs/${found.id}/csv`, {
+      credentials,
+      environment
+    });
+    const csv = await response.text();
+    if (options.output) {
+      await writeFile2(resolve4(process.cwd(), options.output), csv);
+      console.log(`Saved to ${options.output}`);
+    } else {
+      process.stdout.write(csv);
+    }
+  });
+}
+function confirm2(prompt2) {
+  const rl2 = createInterface3({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve7) => {
+    rl2.question(prompt2, (answer) => {
+      rl2.close();
+      resolve7(answer.toLowerCase() === "y");
+    });
+  });
+}
+function openBrowser(url) {
+  console.log(url);
+  const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+  exec(`${cmd} ${JSON.stringify(url)}`);
+}
+
+// src/commands/pull.ts
+import { writeFile as writeFile3 } from "fs/promises";
+import { resolve as resolve5 } from "path";
+function registerPull(program2) {
+  program2.command("pull").description("Download program source from the server").option("-o, --only <key>", "Pull only the specified program (by key)").action(async (options) => {
+    const credentials = await resolveCredentials();
+    const environment = getEnvironment();
+    const config = await loadConfig();
+    const programs = config.programs ?? {};
+    let entries;
+    if (options.only) {
+      const ref = programs[options.only];
+      if (!ref) {
+        console.error(
+          `Program with key "${options.only}" not found in config.`
+        );
+        process.exit(1);
+      }
+      entries = [[options.only, ref]];
+    } else {
+      entries = Object.entries(programs);
+    }
+    if (entries.length === 0) {
+      console.error("No programs in config. Run `gt init` first.");
+      process.exit(1);
+    }
+    console.log(`Pulling from ${environment}...`);
+    for (const [, ref] of entries) {
+      process.stdout.write(
+        `>> Downloading "${ref.file}" (id: ${ref.id})... `
+      );
+      const source = await fetchProgramSource(
+        ref.id,
+        credentials,
+        environment
+      );
+      await writeFile3(resolve5(process.cwd(), ref.file), source);
+      console.log("done");
+    }
+  });
+}
+
+// src/commands/push.ts
+import { readFile as readFile3 } from "fs/promises";
+import { resolve as resolve6 } from "path";
+function registerPush(program2) {
+  program2.command("push").description("Upload local program files to the server").option("-o, --only <key>", "Push only the specified program (by key)").option("-b, --build", "Build after pushing").action(async (options) => {
+    const credentials = await resolveCredentials();
+    const environment = getEnvironment();
+    const config = await loadConfig();
+    const programs = config.programs ?? {};
+    let entries;
+    if (options.only) {
+      const ref = programs[options.only];
+      if (!ref) {
+        console.error(
+          `Program with key "${options.only}" not found in config.`
+        );
+        process.exit(1);
+      }
+      entries = [[options.only, ref]];
+    } else {
+      entries = Object.entries(programs);
+    }
+    if (entries.length === 0) {
+      console.error("No programs in config. Run `gt init` first.");
+      process.exit(1);
+    }
+    console.log(`Pushing to ${environment}...`);
+    const pushed = [];
+    for (const [key, ref] of entries) {
+      process.stdout.write(
+        `>> Updating "${ref.file}" (id: ${ref.id})... `
+      );
+      const contents = await readFile3(
+        resolve6(process.cwd(), ref.file),
+        "utf-8"
+      );
+      await apiRequest(`/programs/${ref.id}.json`, {
+        method: "PUT",
+        credentials,
+        environment,
+        body: { contents, program: { description: "" } }
+      });
+      console.log("done");
+      pushed.push({ file: ref.file, key });
+    }
+    if (options.build && pushed.length > 0) {
+      console.log("\nBuilding pushed programs...");
+      for (const { file, key } of pushed) {
+        await buildProgram(file, key, credentials, environment);
+      }
+    }
+  });
+}
+
+// src/commands/request.ts
+function registerRequest(program2) {
+  program2.command("request").description("Send a generic API request").argument("<path>", "API path (e.g., /programs.json)").option("-X, --method <method>", "HTTP method", "GET").option("-d, --data <json>", "Request body (JSON string)").option(
+    "-H, --header <header...>",
+    "Additional headers (key:value)"
+  ).action(
+    async (path, options) => {
+      const credentials = await resolveCredentials();
+      const environment = getEnvironment();
+      const headers = {};
+      if (options.header) {
+        for (const h of options.header) {
+          const idx = h.indexOf(":");
+          if (idx === -1) {
+            console.error(`Invalid header format: "${h}" (expected key:value)`);
+            process.exit(1);
+          }
+          headers[h.slice(0, idx).trim()] = h.slice(idx + 1).trim();
+        }
+      }
+      let body;
+      if (options.data) {
+        try {
+          body = JSON.parse(options.data);
+        } catch {
+          console.error("Invalid JSON body");
+          process.exit(1);
+        }
+      }
+      const response = await apiRequest(path, {
+        method: options.method,
+        credentials,
+        environment,
+        headers: Object.keys(headers).length > 0 ? headers : void 0,
+        body
+      });
+      const text = await response.text();
+      try {
+        const json = JSON.parse(text);
+        console.log(JSON.stringify(json, null, 2));
+      } catch {
+        console.log(text);
+      }
+    }
+  );
+}
+
+// src/index.ts
+var program = new Command();
+program.name("gt").description("CLI for the GuidedTrack web API").version("0.1.0");
+registerPush(program);
+registerPull(program);
+registerCreate(program);
+registerBuild(program);
+registerCompare(program);
+registerInit(program);
+registerConfig(program);
+registerProgram(program);
+registerRequest(program);
+program.parseAsync().catch((err) => {
+  console.error(err.message);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,43 @@
+{
+  "bin": {
+    "gt": "dist/index.js"
+  },
+  "dependencies": {
+    "commander": "^13.1.0"
+  },
+  "description": "CLI for the GuidedTrack web API",
+  "devDependencies": {
+    "@eslint/css": "^0.14.1",
+    "@eslint/js": "^9.12.0",
+    "@eslint/json": "^0.14.0",
+    "@eslint/markdown": "^7.5.1",
+    "@types/node": "^22.15.0",
+    "eslint": "^9.39.1",
+    "eslint-plugin-html": "^7.1.0",
+    "globals": "^15.11.0",
+    "prettier": "^3.7.1",
+    "tsup": "^8.4.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.8.0",
+    "typescript-eslint": "^8.31.0",
+    "vitest": "^3.1.0"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "files": [
+    "dist"
+  ],
+  "name": "@jrc03c/gt-cli",
+  "scripts": {
+    "build": "tsup && chmod +x dist/index.js",
+    "dev": "tsx src/index.ts",
+    "format": "prettier --write .",
+    "lint": "eslint .",
+    "pub": "npm version patch --force && npm publish --access=public",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "type": "module",
+  "version": "0.1.1"
+}