@prajwolkc/stk 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 prajwolkc
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,114 @@
+# stk
+
+One CLI to deploy, monitor, and debug your entire stack.
+
+Stop opening 5 dashboards. `stk` checks your services, watches your deploys, syncs your env vars, tails your logs, and manages your issues — all from one command.
+
+## Install
+
+```bash
+npm install -g stk-cli
+```
+
+## Quick Start
+
+```bash
+cd my-project
+stk init                      # auto-detect your services
+stk init --template saas      # or use a starter template
+stk health                    # check everything
+stk status                    # one-line summary of your whole stack
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `stk init` | Initialize config (auto-detect or `--template saas\|api\|fullstack\|static\|fly\|aws`) |
+| `stk status` | One-line summary: git, services, deploys, issues |
+| `stk health` | Health check all configured services |
+| `stk deploy` | Git push + watch Railway/Vercel/Fly deploys |
+| `stk env pull` | Pull env vars from Vercel + Railway into `.env.pulled` |
+| `stk env diff` | Show what's in your local `.env` |
+| `stk logs` | Tail Railway deployment logs |
+| `stk todo ls` | List open GitHub issues |
+| `stk todo add "title"` | Create a GitHub issue |
+| `stk todo close 42` | Close an issue |
+
+## Supported Services
+
+**Deploy providers:** Railway, Vercel, Fly.io, Render, AWS
+**Databases:** PostgreSQL, MongoDB, Redis, Supabase
+**Storage & billing:** Cloudflare R2, Stripe
+
+## Configuration
+
+`stk init` creates a `stk.config.json` in your project root:
+
+```json
+{
+  "name": "my-saas",
+  "services": {
+    "vercel": true,
+    "railway": true,
+    "database": true,
+    "redis": true,
+    "stripe": true,
+    "r2": true
+  },
+  "deploy": {
+    "branch": "main",
+    "providers": ["vercel", "railway"]
+  }
+}
+```
+
+Only configured services are checked — no noise from services you don't use.
+
+If no config file exists, `stk` auto-detects services from your environment variables.
+
+## Templates
+
+```bash
+stk init --list-templates
+```
+
+| Template | Stack |
+|----------|-------|
+| `saas` | Vercel + Railway + PostgreSQL + Redis + Stripe + R2 |
+| `api` | Railway + PostgreSQL + Redis |
+| `fullstack` | Vercel + Railway + Supabase + Stripe |
+| `static` | Vercel only |
+| `fly` | Fly.io + PostgreSQL + Redis |
+| `aws` | AWS + PostgreSQL + Redis |
+
+## Environment Variables
+
+Set the tokens for your services:
+
+```bash
+# Deploy providers
+RAILWAY_API_TOKEN=
+VERCEL_TOKEN=
+FLY_API_TOKEN=
+RENDER_API_KEY=
+AWS_ACCESS_KEY_ID= / AWS_SECRET_ACCESS_KEY=
+
+# Databases
+DATABASE_URL=
+MONGODB_URL=
+REDIS_URL=
+SUPABASE_URL= / SUPABASE_SERVICE_KEY=
+
+# Storage & billing
+CLOUDFLARE_ACCOUNT_ID= / CLOUDFLARE_API_TOKEN=
+STRIPE_SECRET_KEY=
+
+# GitHub (for stk todo)
+GITHUB_TOKEN=
+GITHUB_REPO=owner/repo   # or auto-detected from git remote
+```
+
+## License
+
+MIT

package/dist/commands/deploy.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const deployCommand: Command;

package/dist/commands/deploy.js

@@ -0,0 +1,152 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import { execSync } from "child_process";
+import { loadConfig, enabledServices } from "../lib/config.js";
+const DEPLOY_PROVIDERS = {
+    vercel: watchVercel,
+    railway: watchRailway,
+};
+export const deployCommand = new Command("deploy")
+    .description("Push to branch and watch deploy providers")
+    .option("-b, --branch <branch>", "branch to push (default: from config or main)")
+    .option("--skip-push", "skip git push, just watch deploys")
+    .action(async (opts) => {
+    const config = loadConfig();
+    const branch = opts.branch ?? config.deploy?.branch ?? "main";
+    // Step 1: Git push
+    if (!opts.skipPush) {
+        const pushSpinner = ora("Pushing to remote...").start();
+        try {
+            const currentBranch = execSync("git rev-parse --abbrev-ref HEAD", {
+                encoding: "utf-8",
+            }).trim();
+            if (currentBranch !== branch) {
+                pushSpinner.warn(`You're on ${chalk.yellow(currentBranch)}, not ${chalk.green(branch)}`);
+                console.log(chalk.dim(`  Run: git checkout ${branch} && git merge ${currentBranch}`));
+                return;
+            }
+            execSync(`git push origin ${branch}`, {
+                encoding: "utf-8",
+                stdio: "pipe",
+            });
+            pushSpinner.succeed(`Pushed to ${chalk.green(`origin/${branch}`)}`);
+        }
+        catch (err) {
+            pushSpinner.fail("Git push failed");
+            console.error(chalk.red(`  ${err.message}`));
+            process.exitCode = 1;
+            return;
+        }
+    }
+    // Step 2: Watch deploys — only providers enabled in config
+    console.log();
+    console.log(chalk.bold(`  ${config.name} — Watching deploys...`));
+    console.log(chalk.dim("  ─────────────────────────────────────────"));
+    const providers = config.deploy?.providers ?? enabledServices(config).filter((s) => s in DEPLOY_PROVIDERS);
+    const watchers = [];
+    for (const provider of providers) {
+        const watcher = DEPLOY_PROVIDERS[provider];
+        if (watcher) {
+            watchers.push(watcher());
+        }
+        else {
+            console.log(chalk.dim(`  ○  ${provider}  no deploy watcher available`));
+        }
+    }
+    if (watchers.length === 0) {
+        console.log(chalk.yellow("  No deploy providers configured."));
+        console.log(chalk.dim(`  Add "deploy.providers" to stk.config.json`));
+    }
+    else {
+        await Promise.all(watchers);
+    }
+    console.log();
+});
+async function watchVercel() {
+    const token = process.env.VERCEL_TOKEN;
+    const spinner = ora({ text: "Vercel deploying...", indent: 2 }).start();
+    for (let i = 0; i < 60; i++) {
+        await sleep(5000);
+        try {
+            const res = await fetch("https://api.vercel.com/v6/deployments?limit=1", {
+                headers: { Authorization: `Bearer ${token}` },
+            });
+            const data = (await res.json());
+            const dep = data.deployments?.[0];
+            if (!dep)
+                continue;
+            const state = dep.readyState ?? dep.state;
+            if (state === "READY") {
+                spinner.succeed(`Vercel ${chalk.green("ready")} — ${chalk.dim(dep.url)}`);
+                return;
+            }
+            else if (state === "ERROR") {
+                spinner.fail(`Vercel deploy ${chalk.red("failed")}`);
+                process.exitCode = 1;
+                return;
+            }
+            spinner.text = `Vercel: ${state.toLowerCase()}...`;
+        }
+        catch {
+            // retry
+        }
+    }
+    spinner.warn("Vercel: timed out waiting (5 min)");
+}
+async function watchRailway() {
+    const token = process.env.RAILWAY_API_TOKEN;
+    const spinner = ora({ text: "Railway deploying...", indent: 2 }).start();
+    for (let i = 0; i < 60; i++) {
+        await sleep(5000);
+        try {
+            const res = await fetch("https://backboard.railway.com/graphql/v2", {
+                method: "POST",
+                headers: {
+                    Authorization: `Bearer ${token}`,
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({
+                    query: `{
+            me {
+              projects(first: 1) {
+                edges {
+                  node {
+                    deployments(first: 1) {
+                      edges {
+                        node { status }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }`,
+                }),
+            });
+            const data = (await res.json());
+            const deployment = data.data?.me?.projects?.edges?.[0]?.node?.deployments?.edges?.[0]
+                ?.node;
+            if (!deployment)
+                continue;
+            const status = deployment.status;
+            if (status === "SUCCESS") {
+                spinner.succeed(`Railway ${chalk.green("deployed")}`);
+                return;
+            }
+            else if (status === "FAILED" || status === "CRASHED") {
+                spinner.fail(`Railway deploy ${chalk.red(status.toLowerCase())}`);
+                process.exitCode = 1;
+                return;
+            }
+            spinner.text = `Railway: ${status.toLowerCase()}...`;
+        }
+        catch {
+            // retry
+        }
+    }
+    spinner.warn("Railway: timed out waiting (5 min)");
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/commands/env.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const envCommand: Command;

package/dist/commands/env.js

@@ -0,0 +1,136 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import { writeFileSync, readFileSync, existsSync } from "fs";
+export const envCommand = new Command("env")
+    .description("Sync environment variables across services");
+envCommand
+    .command("pull")
+    .description("Pull env vars from Vercel and Railway into a local .env file")
+    .option("-o, --output <file>", "output file", ".env.pulled")
+    .action(async (opts) => {
+    const vars = {};
+    const spinner = ora("Pulling env vars...").start();
+    // Pull from Vercel
+    if (process.env.VERCEL_TOKEN) {
+        spinner.text = "Pulling from Vercel...";
+        try {
+            const projectId = process.env.VERCEL_PROJECT_ID;
+            const url = projectId
+                ? `https://api.vercel.com/v9/projects/${projectId}/env`
+                : "https://api.vercel.com/v9/projects";
+            if (!projectId) {
+                spinner.warn("Vercel: set VERCEL_PROJECT_ID to pull env vars (skipping)");
+            }
+            else {
+                const res = await fetch(url, {
+                    headers: { Authorization: `Bearer ${process.env.VERCEL_TOKEN}` },
+                });
+                if (!res.ok)
+                    throw new Error(`HTTP ${res.status}`);
+                const data = (await res.json());
+                const envVars = data.envs ?? [];
+                for (const env of envVars) {
+                    if (env.value) {
+                        vars[env.key] = { value: env.value, source: "vercel" };
+                    }
+                }
+                console.log(chalk.dim(`  Vercel: pulled ${envVars.length} variables`));
+            }
+        }
+        catch (err) {
+            console.log(chalk.yellow(`  Vercel: ${err.message}`));
+        }
+    }
+    else {
+        console.log(chalk.dim("  ○  Vercel skipped (VERCEL_TOKEN not set)"));
+    }
+    // Pull from Railway
+    if (process.env.RAILWAY_API_TOKEN) {
+        spinner.text = "Pulling from Railway...";
+        try {
+            const projectId = process.env.RAILWAY_PROJECT_ID;
+            const environmentId = process.env.RAILWAY_ENVIRONMENT_ID;
+            const serviceId = process.env.RAILWAY_SERVICE_ID;
+            if (!projectId || !environmentId || !serviceId) {
+                console.log(chalk.dim("  ○  Railway: set RAILWAY_PROJECT_ID, RAILWAY_ENVIRONMENT_ID, RAILWAY_SERVICE_ID to pull env vars"));
+            }
+            else {
+                const res = await fetch("https://backboard.railway.com/graphql/v2", {
+                    method: "POST",
+                    headers: {
+                        Authorization: `Bearer ${process.env.RAILWAY_API_TOKEN}`,
+                        "Content-Type": "application/json",
+                    },
+                    body: JSON.stringify({
+                        query: `query {
+                  variables(
+                    projectId: "${projectId}",
+                    environmentId: "${environmentId}",
+                    serviceId: "${serviceId}"
+                  )
+                }`,
+                    }),
+                });
+                if (!res.ok)
+                    throw new Error(`HTTP ${res.status}`);
+                const data = (await res.json());
+                const railwayVars = data.data?.variables ?? {};
+                for (const [key, value] of Object.entries(railwayVars)) {
+                    if (!vars[key]) {
+                        vars[key] = { value: value, source: "railway" };
+                    }
+                }
+                console.log(chalk.dim(`  Railway: pulled ${Object.keys(railwayVars).length} variables`));
+            }
+        }
+        catch (err) {
+            console.log(chalk.yellow(`  Railway: ${err.message}`));
+        }
+    }
+    else {
+        console.log(chalk.dim("  ○  Railway skipped (RAILWAY_API_TOKEN not set)"));
+    }
+    spinner.stop();
+    // Write to file
+    const lines = Object.entries(vars)
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([key, { value, source }]) => `# source: ${source}\n${key}=${value}`);
+    if (lines.length === 0) {
+        console.log(chalk.yellow("\n  No env vars pulled."));
+        return;
+    }
+    writeFileSync(opts.output, lines.join("\n\n") + "\n");
+    console.log(`\n  ${chalk.green("✓")} Wrote ${Object.keys(vars).length} variables to ${chalk.bold(opts.output)}`);
+});
+envCommand
+    .command("diff")
+    .description("Compare local .env with remote services")
+    .option("-f, --file <file>", "local env file to compare", ".env")
+    .action(async (opts) => {
+    if (!existsSync(opts.file)) {
+        console.log(chalk.red(`  File not found: ${opts.file}`));
+        process.exitCode = 1;
+        return;
+    }
+    const local = parseEnvFile(readFileSync(opts.file, "utf-8"));
+    console.log(`\n  Local ${chalk.bold(opts.file)}: ${Object.keys(local).length} variables`);
+    console.log(chalk.dim("  ─────────────────────────────────────────"));
+    for (const [key] of Object.entries(local).sort(([a], [b]) => a.localeCompare(b))) {
+        console.log(`  ${chalk.dim("•")}  ${key}`);
+    }
+    console.log();
+});
+function parseEnvFile(content) {
+    const vars = {};
+    for (const line of content.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#"))
+            continue;
+        const eqIdx = trimmed.indexOf("=");
+        if (eqIdx === -1)
+            continue;
+        vars[trimmed.slice(0, eqIdx)] = trimmed.slice(eqIdx + 1);
+    }
+    return vars;
+}

package/dist/commands/health.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const healthCommand: Command;

package/dist/commands/health.js

@@ -0,0 +1,77 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import { loadConfig, enabledServices } from "../lib/config.js";
+import { getChecker, allCheckerNames } from "../services/registry.js";
+const STATUS_ICON = {
+    healthy: chalk.green("✓"),
+    degraded: chalk.yellow("~"),
+    down: chalk.red("✗"),
+    skipped: chalk.dim("○"),
+};
+const STATUS_COLOR = {
+    healthy: chalk.green,
+    degraded: chalk.yellow,
+    down: chalk.red,
+    skipped: chalk.dim,
+};
+export const healthCommand = new Command("health")
+    .description("Check the health of all connected services")
+    .option("-v, --verbose", "Show latency and extra detail")
+    .option("-a, --all", "Check all known services, not just configured ones")
+    .action(async (opts) => {
+    const config = loadConfig();
+    const spinner = ora("Checking services...").start();
+    const serviceList = opts.all
+        ? allCheckerNames()
+        : enabledServices(config);
+    if (serviceList.length === 0) {
+        spinner.stop();
+        console.log();
+        console.log(chalk.yellow("  No services configured."));
+        console.log(chalk.dim(`  Run ${chalk.white("stk init")} to set up your project, or ${chalk.white("stk health --all")} to check everything.`));
+        console.log();
+        return;
+    }
+    const checks = serviceList.map((name) => {
+        const checker = getChecker(name);
+        if (!checker) {
+            return Promise.resolve({
+                name,
+                status: "skipped",
+                detail: `unknown service "${name}"`,
+            });
+        }
+        return checker();
+    });
+    const results = await Promise.all(checks);
+    spinner.stop();
+    console.log();
+    console.log(chalk.bold(`  ${config.name} — Service Health`));
+    console.log(chalk.dim("  ─────────────────────────────────────────"));
+    for (const r of results) {
+        const icon = STATUS_ICON[r.status];
+        const name = r.name.padEnd(16);
+        const latencyStr = opts.verbose && r.latency != null ? chalk.dim(` ${r.latency}ms`) : "";
+        const detail = r.detail ? chalk.dim(`  ${r.detail}`) : "";
+        console.log(`  ${icon}  ${STATUS_COLOR[r.status](name)}${latencyStr}${detail}`);
+    }
+    console.log();
+    const down = results.filter((r) => r.status === "down");
+    const healthy = results.filter((r) => r.status === "healthy");
+    const skipped = results.filter((r) => r.status === "skipped");
+    if (down.length > 0) {
+        console.log(chalk.red(`  ${down.length} service${down.length > 1 ? "s" : ""} down`));
+        process.exitCode = 1;
+    }
+    else if (healthy.length === 0) {
+        console.log(chalk.yellow("  No services reachable — check your env vars"));
+    }
+    else {
+        console.log(chalk.green(`  All ${healthy.length} configured service${healthy.length > 1 ? "s" : ""} healthy`));
+    }
+    if (skipped.length > 0 && opts.verbose) {
+        console.log(chalk.dim(`  ${skipped.length} skipped (missing env vars)`));
+    }
+    console.log();
+});

package/dist/commands/init.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const initCommand: Command;

package/dist/commands/init.js

@@ -0,0 +1,111 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import { writeFileSync, existsSync } from "fs";
+import { basename } from "path";
+import { CONFIG_FILE, KNOWN_SERVICES } from "../lib/config.js";
+import { templates, listTemplates } from "../templates/index.js";
+const DEPLOY_PROVIDERS = ["railway", "vercel", "fly", "render", "aws"];
+export const initCommand = new Command("init")
+    .description("Initialize stk config for the current project")
+    .option("--force", "overwrite existing config")
+    .option("-t, --template <name>", `use a starter template (${listTemplates().join(", ")})`)
+    .option("--list-templates", "show available templates")
+    .action(async (opts) => {
+    // List templates
+    if (opts.listTemplates) {
+        console.log();
+        console.log(chalk.bold("  Available Templates"));
+        console.log(chalk.dim("  ─────────────────────────────────────────"));
+        for (const [key, tpl] of Object.entries(templates)) {
+            console.log(`  ${chalk.green(key.padEnd(12))} ${tpl.name}`);
+            console.log(`  ${" ".repeat(12)} ${chalk.dim(tpl.description)}`);
+        }
+        console.log();
+        console.log(chalk.dim(`  Usage: stk init --template saas`));
+        console.log();
+        return;
+    }
+    if (existsSync(CONFIG_FILE) && !opts.force) {
+        console.log(chalk.yellow(`  ${CONFIG_FILE} already exists. Use --force to overwrite.`));
+        return;
+    }
+    const projectName = basename(process.cwd());
+    // Template-based init
+    if (opts.template) {
+        const tpl = templates[opts.template];
+        if (!tpl) {
+            console.log(chalk.red(`  Unknown template: "${opts.template}"`));
+            console.log(chalk.dim(`  Available: ${listTemplates().join(", ")}`));
+            return;
+        }
+        const config = {
+            ...tpl.config,
+            name: projectName,
+        };
+        writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + "\n");
+        console.log();
+        console.log(`  ${chalk.green("✓")} Created ${chalk.bold(CONFIG_FILE)} from ${chalk.cyan(tpl.name)} template`);
+        console.log();
+        console.log(chalk.bold("  Services:"));
+        for (const [name, enabled] of Object.entries(config.services)) {
+            const icon = enabled ? chalk.green("✓") : chalk.dim("○");
+            console.log(`  ${icon}  ${enabled ? chalk.white(name) : chalk.dim(name)}`);
+        }
+        console.log();
+        console.log(chalk.dim(`  Deploy branch: ${config.deploy?.branch ?? "main"}`));
+        console.log(chalk.dim(`  Deploy providers: ${config.deploy?.providers?.join(", ") || "none"}`));
+        console.log();
+        console.log(chalk.dim(`  Set your env vars, then run ${chalk.white("stk health")} to verify.`));
+        console.log();
+        return;
+    }
+    // Auto-detect init
+    const detected = {};
+    const envChecks = {
+        railway: ["RAILWAY_API_TOKEN"],
+        vercel: ["VERCEL_TOKEN"],
+        fly: ["FLY_API_TOKEN"],
+        render: ["RENDER_API_KEY"],
+        aws: ["AWS_ACCESS_KEY_ID"],
+        database: ["DATABASE_URL"],
+        mongodb: ["MONGODB_URL", "MONGO_URL"],
+        redis: ["REDIS_URL"],
+        supabase: ["SUPABASE_URL"],
+        r2: ["CLOUDFLARE_ACCOUNT_ID"],
+        stripe: ["STRIPE_SECRET_KEY"],
+    };
+    for (const [service, vars] of Object.entries(envChecks)) {
+        if (vars.some((v) => process.env[v])) {
+            detected[service] = true;
+        }
+    }
+    const config = {
+        name: projectName,
+        services: {
+            ...Object.fromEntries(KNOWN_SERVICES.map((s) => [s, false])),
+            ...detected,
+        },
+        deploy: {
+            branch: "main",
+            providers: Object.keys(detected).filter((s) => DEPLOY_PROVIDERS.includes(s)),
+        },
+    };
+    writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + "\n");
+    console.log();
+    console.log(`  ${chalk.green("✓")} Created ${chalk.bold(CONFIG_FILE)}`);
+    console.log();
+    console.log(chalk.bold("  Detected services:"));
+    const serviceNames = Object.entries(config.services);
+    for (const [name, enabled] of serviceNames) {
+        const icon = enabled ? chalk.green("✓") : chalk.dim("○");
+        const label = enabled
+            ? chalk.white(name)
+            : chalk.dim(`${name} (not detected — enable in config)`);
+        console.log(`  ${icon}  ${label}`);
+    }
+    console.log();
+    console.log(chalk.dim(`  Edit ${CONFIG_FILE} to enable/disable services or add config.`));
+    console.log(chalk.dim(`  Or try: ${chalk.white("stk init --template saas")} for a pre-configured stack.`));
+    console.log(chalk.dim(`  Then run ${chalk.white("stk health")} to verify.`));
+    console.log();
+});

package/dist/commands/logs.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const logsCommand: Command;