@prajwolkc/stk 0.1.0

package/dist/commands/logs.js

@@ -0,0 +1,151 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+export const logsCommand = new Command("logs")
+    .description("Tail Railway runtime logs locally")
+    .option("-n, --lines <count>", "number of recent lines to show", "50")
+    .option("-f, --follow", "keep streaming new logs")
+    .action(async (opts) => {
+    const token = process.env.RAILWAY_API_TOKEN;
+    if (!token) {
+        console.log(chalk.red("  RAILWAY_API_TOKEN not set"));
+        process.exitCode = 1;
+        return;
+    }
+    const projectId = process.env.RAILWAY_PROJECT_ID;
+    const serviceId = process.env.RAILWAY_SERVICE_ID;
+    const deploymentId = process.env.RAILWAY_DEPLOYMENT_ID;
+    if (!deploymentId) {
+        // Try to get latest deployment
+        const spinner = ora("Fetching latest deployment...").start();
+        try {
+            const latestDeploymentId = await getLatestDeploymentId(token, projectId, serviceId);
+            if (latestDeploymentId) {
+                spinner.succeed(`Found deployment ${chalk.dim(latestDeploymentId.slice(0, 8))}`);
+                await fetchAndPrintLogs(token, latestDeploymentId, parseInt(opts.lines, 10));
+                if (opts.follow) {
+                    await followLogs(token, latestDeploymentId);
+                }
+            }
+            else {
+                spinner.fail("No deployments found");
+                console.log(chalk.dim("  Set RAILWAY_PROJECT_ID and RAILWAY_SERVICE_ID, or RAILWAY_DEPLOYMENT_ID"));
+            }
+        }
+        catch (err) {
+            spinner.fail(err.message);
+        }
+        return;
+    }
+    await fetchAndPrintLogs(token, deploymentId, parseInt(opts.lines, 10));
+    if (opts.follow) {
+        await followLogs(token, deploymentId);
+    }
+});
+async function getLatestDeploymentId(token, projectId, serviceId) {
+    if (!projectId)
+        return null;
+    const serviceFilter = serviceId
+        ? `serviceId: "${serviceId}",`
+        : "";
+    const res = await fetch("https://backboard.railway.com/graphql/v2", {
+        method: "POST",
+        headers: {
+            Authorization: `Bearer ${token}`,
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+            query: `{
+        deployments(
+          first: 1,
+          input: {
+            projectId: "${projectId}",
+            ${serviceFilter}
+          }
+        ) {
+          edges {
+            node { id status }
+          }
+        }
+      }`,
+        }),
+    });
+    const data = (await res.json());
+    return data.data?.deployments?.edges?.[0]?.node?.id ?? null;
+}
+async function fetchAndPrintLogs(token, deploymentId, limit) {
+    const res = await fetch("https://backboard.railway.com/graphql/v2", {
+        method: "POST",
+        headers: {
+            Authorization: `Bearer ${token}`,
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+            query: `{
+        deploymentLogs(deploymentId: "${deploymentId}", limit: ${limit}) {
+          timestamp
+          message
+          severity
+        }
+      }`,
+        }),
+    });
+    const data = (await res.json());
+    const logs = data.data?.deploymentLogs ?? [];
+    if (logs.length === 0) {
+        console.log(chalk.dim("  No logs found"));
+        return;
+    }
+    for (const log of logs) {
+        printLogLine(log);
+    }
+}
+async function followLogs(token, deploymentId) {
+    console.log(chalk.dim("\n  --- streaming (Ctrl+C to stop) ---\n"));
+    let lastTimestamp = new Date().toISOString();
+    while (true) {
+        await sleep(3000);
+        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: `{
+            deploymentLogs(deploymentId: "${deploymentId}", limit: 20, filter: "${lastTimestamp}") {
+              timestamp
+              message
+              severity
+            }
+          }`,
+                }),
+            });
+            const data = (await res.json());
+            const logs = data.data?.deploymentLogs ?? [];
+            for (const log of logs) {
+                if (log.timestamp > lastTimestamp) {
+                    printLogLine(log);
+                    lastTimestamp = log.timestamp;
+                }
+            }
+        }
+        catch {
+            // retry silently
+        }
+    }
+}
+function printLogLine(log) {
+    const time = chalk.dim(new Date(log.timestamp).toLocaleTimeString());
+    const severity = log.severity?.toUpperCase() ?? "INFO";
+    const sevColor = severity === "ERROR"
+        ? chalk.red
+        : severity === "WARN"
+            ? chalk.yellow
+            : chalk.dim;
+    console.log(`  ${time}  ${sevColor(severity.padEnd(5))}  ${log.message}`);
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/commands/status.d.ts

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

package/dist/commands/status.js

@@ -0,0 +1,130 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import { execSync } from "child_process";
+import { loadConfig, enabledServices } from "../lib/config.js";
+import { getChecker } from "../services/registry.js";
+export const statusCommand = new Command("status")
+    .description("One-line summary of your entire stack")
+    .action(async () => {
+    const config = loadConfig();
+    const spinner = ora("Checking everything...").start();
+    const sections = [];
+    // 1. Git status
+    try {
+        const branch = execSync("git rev-parse --abbrev-ref HEAD", {
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
+        }).trim();
+        const status = execSync("git status --porcelain", {
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
+        }).trim();
+        const dirty = status.split("\n").filter(Boolean).length;
+        const lastCommit = execSync('git log -1 --format="%s" 2>/dev/null', {
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
+        }).trim();
+        const commitAge = execSync('git log -1 --format="%cr" 2>/dev/null', {
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
+        }).trim();
+        const branchStr = chalk.cyan(branch);
+        const dirtyStr = dirty > 0 ? chalk.yellow(` ${dirty} changed`) : chalk.green(" clean");
+        sections.push(`  ${chalk.bold("Git")}        ${branchStr}${dirtyStr}  ${chalk.dim(`"${lastCommit}" ${commitAge}`)}`);
+    }
+    catch {
+        sections.push(`  ${chalk.bold("Git")}        ${chalk.dim("not a git repo")}`);
+    }
+    // 2. Service health (parallel)
+    const serviceList = enabledServices(config);
+    let healthLine;
+    if (serviceList.length === 0) {
+        healthLine = chalk.dim("no services configured");
+    }
+    else {
+        const checks = serviceList.map((name) => {
+            const checker = getChecker(name);
+            if (!checker) {
+                return Promise.resolve({
+                    name,
+                    status: "skipped",
+                    detail: "unknown",
+                });
+            }
+            return checker();
+        });
+        const results = await Promise.all(checks);
+        const up = results.filter((r) => r.status === "healthy").length;
+        const down = results.filter((r) => r.status === "down");
+        const skipped = results.filter((r) => r.status === "skipped").length;
+        if (down.length > 0) {
+            const downNames = down.map((d) => d.name).join(", ");
+            healthLine = `${chalk.green(`${up} up`)} ${chalk.red(`${down.length} down`)} (${chalk.red(downNames)})`;
+        }
+        else if (up > 0) {
+            healthLine = chalk.green(`${up}/${serviceList.length} healthy`);
+        }
+        else {
+            healthLine = chalk.yellow(`${skipped} skipped (check env vars)`);
+        }
+    }
+    sections.push(`  ${chalk.bold("Services")}   ${healthLine}`);
+    // 3. Last deploy info (quick check for deploy providers)
+    const deployProviders = config.deploy?.providers ?? [];
+    if (deployProviders.includes("vercel") && process.env.VERCEL_TOKEN) {
+        try {
+            const res = await fetch("https://api.vercel.com/v6/deployments?limit=1", {
+                headers: { Authorization: `Bearer ${process.env.VERCEL_TOKEN}` },
+            });
+            const data = (await res.json());
+            const dep = data.deployments?.[0];
+            if (dep) {
+                const state = dep.readyState ?? dep.state;
+                const ago = timeSince(new Date(dep.created));
+                const stateColor = state === "READY" ? chalk.green : state === "ERROR" ? chalk.red : chalk.yellow;
+                sections.push(`  ${chalk.bold("Deploy")}     Vercel: ${stateColor(state.toLowerCase())} ${chalk.dim(`${ago} ago`)}`);
+            }
+        }
+        catch { /* skip */ }
+    }
+    // 4. Open issues count
+    const ghRepo = config.github?.repo ?? process.env.GITHUB_REPO;
+    if (ghRepo) {
+        try {
+            const headers = {
+                Accept: "application/vnd.github+json",
+            };
+            if (process.env.GITHUB_TOKEN) {
+                headers.Authorization = `Bearer ${process.env.GITHUB_TOKEN}`;
+            }
+            const res = await fetch(`https://api.github.com/repos/${ghRepo}`, { headers });
+            if (res.ok) {
+                const repo = (await res.json());
+                sections.push(`  ${chalk.bold("Issues")}     ${chalk.white(repo.open_issues_count)} open`);
+            }
+        }
+        catch { /* skip */ }
+    }
+    spinner.stop();
+    console.log();
+    console.log(chalk.bold(`  ${config.name} — Status`));
+    console.log(chalk.dim("  ─────────────────────────────────────────"));
+    for (const section of sections) {
+        console.log(section);
+    }
+    console.log();
+});
+function timeSince(date) {
+    const seconds = Math.floor((Date.now() - date.getTime()) / 1000);
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours}h`;
+    const days = Math.floor(hours / 24);
+    return `${days}d`;
+}

package/dist/commands/todo.d.ts

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

package/dist/commands/todo.js

@@ -0,0 +1,187 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import { loadConfig } from "../lib/config.js";
+export const todoCommand = new Command("todo")
+    .description("Manage project todos from GitHub Issues");
+todoCommand
+    .command("list")
+    .alias("ls")
+    .description("List open issues")
+    .option("-l, --label <label>", "filter by label")
+    .option("-a, --assignee <user>", "filter by assignee (use @me for yourself)")
+    .option("-n, --limit <count>", "max issues to show", "15")
+    .action(async (opts) => {
+    const { repo, token } = getGitHubConfig();
+    if (!repo)
+        return;
+    const spinner = ora("Fetching issues...").start();
+    try {
+        const params = new URLSearchParams({
+            state: "open",
+            per_page: opts.limit,
+            sort: "updated",
+            direction: "desc",
+        });
+        if (opts.label)
+            params.set("labels", opts.label);
+        if (opts.assignee)
+            params.set("assignee", opts.assignee === "@me" ? "" : opts.assignee);
+        const res = await fetch(`https://api.github.com/repos/${repo}/issues?${params}`, { headers: ghHeaders(token) });
+        if (!res.ok)
+            throw new Error(`HTTP ${res.status}`);
+        const issues = (await res.json());
+        spinner.stop();
+        // Filter out pull requests
+        const filtered = issues.filter((i) => !i.pull_request);
+        if (filtered.length === 0) {
+            console.log(chalk.dim("\n  No open issues found.\n"));
+            return;
+        }
+        console.log();
+        console.log(chalk.bold(`  ${repo} — Open Issues`));
+        console.log(chalk.dim("  ─────────────────────────────────────────"));
+        for (const issue of filtered) {
+            const num = chalk.dim(`#${issue.number}`);
+            const labels = issue.labels
+                .map((l) => chalk.hex(l.color ?? "888888")(l.name))
+                .join(" ");
+            const assignee = issue.assignee
+                ? chalk.dim(` @${issue.assignee.login}`)
+                : "";
+            const age = timeSince(new Date(issue.created_at));
+            console.log(`  ${num}  ${issue.title}  ${labels}${assignee}  ${chalk.dim(age)}`);
+        }
+        console.log();
+    }
+    catch (err) {
+        spinner.fail(err.message);
+    }
+});
+todoCommand
+    .command("add <title>")
+    .description("Create a new GitHub issue")
+    .option("-b, --body <body>", "issue body")
+    .option("-l, --label <labels>", "comma-separated labels")
+    .option("-a, --assignee <user>", "assign to user")
+    .action(async (title, opts) => {
+    const { repo, token } = getGitHubConfig();
+    if (!repo || !token) {
+        if (!token)
+            console.log(chalk.red("  GITHUB_TOKEN required to create issues"));
+        return;
+    }
+    const spinner = ora("Creating issue...").start();
+    try {
+        const body = { title };
+        if (opts.body)
+            body.body = opts.body;
+        if (opts.label)
+            body.labels = opts.label.split(",").map((s) => s.trim());
+        if (opts.assignee)
+            body.assignees = [opts.assignee];
+        const res = await fetch(`https://api.github.com/repos/${repo}/issues`, {
+            method: "POST",
+            headers: { ...ghHeaders(token), "Content-Type": "application/json" },
+            body: JSON.stringify(body),
+        });
+        if (!res.ok) {
+            const data = (await res.json());
+            throw new Error(data.message ?? `HTTP ${res.status}`);
+        }
+        const issue = (await res.json());
+        spinner.succeed(`Created ${chalk.bold(`#${issue.number}`)} — ${issue.html_url}`);
+    }
+    catch (err) {
+        spinner.fail(err.message);
+    }
+});
+todoCommand
+    .command("close <number>")
+    .description("Close an issue by number")
+    .option("-c, --comment <text>", "add a closing comment")
+    .action(async (number, opts) => {
+    const { repo, token } = getGitHubConfig();
+    if (!repo || !token) {
+        if (!token)
+            console.log(chalk.red("  GITHUB_TOKEN required to close issues"));
+        return;
+    }
+    const spinner = ora(`Closing #${number}...`).start();
+    try {
+        if (opts.comment) {
+            await fetch(`https://api.github.com/repos/${repo}/issues/${number}/comments`, {
+                method: "POST",
+                headers: { ...ghHeaders(token), "Content-Type": "application/json" },
+                body: JSON.stringify({ body: opts.comment }),
+            });
+        }
+        const res = await fetch(`https://api.github.com/repos/${repo}/issues/${number}`, {
+            method: "PATCH",
+            headers: { ...ghHeaders(token), "Content-Type": "application/json" },
+            body: JSON.stringify({ state: "closed" }),
+        });
+        if (!res.ok)
+            throw new Error(`HTTP ${res.status}`);
+        spinner.succeed(`Closed #${number}`);
+    }
+    catch (err) {
+        spinner.fail(err.message);
+    }
+});
+function getGitHubConfig() {
+    const token = process.env.GITHUB_TOKEN ?? null;
+    const config = loadConfig();
+    const repo = config.github?.repo ??
+        process.env.GITHUB_REPO ??
+        detectGitHubRepo();
+    if (!repo) {
+        console.log(chalk.red("  Could not detect GitHub repo."));
+        console.log(chalk.dim('  Set GITHUB_REPO=owner/repo or add "github.repo" to stk.config.json'));
+        return { repo: null, token };
+    }
+    return { repo, token };
+}
+function detectGitHubRepo() {
+    try {
+        const { execSync } = require("child_process");
+        const url = execSync("git remote get-url origin", {
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
+        }).trim();
+        // Handle SSH: git@github.com:owner/repo.git
+        const sshMatch = url.match(/github\.com[:/]([^/]+\/[^/.]+)/);
+        if (sshMatch)
+            return sshMatch[1];
+        // Handle HTTPS: https://github.com/owner/repo.git
+        const httpsMatch = url.match(/github\.com\/([^/]+\/[^/.]+)/);
+        if (httpsMatch)
+            return httpsMatch[1];
+    }
+    catch {
+        // not a git repo or no remote
+    }
+    return null;
+}
+function ghHeaders(token) {
+    const headers = {
+        Accept: "application/vnd.github+json",
+        "X-GitHub-Api-Version": "2022-11-28",
+    };
+    if (token)
+        headers.Authorization = `Bearer ${token}`;
+    return headers;
+}
+function timeSince(date) {
+    const seconds = Math.floor((Date.now() - date.getTime()) / 1000);
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours}h`;
+    const days = Math.floor(hours / 24);
+    return `${days}d`;
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { initCommand } from "./commands/init.js";
+import { statusCommand } from "./commands/status.js";
+import { healthCommand } from "./commands/health.js";
+import { deployCommand } from "./commands/deploy.js";
+import { envCommand } from "./commands/env.js";
+import { logsCommand } from "./commands/logs.js";
+import { todoCommand } from "./commands/todo.js";
+const program = new Command();
+program
+    .name("stk")
+    .description("One CLI to deploy, monitor, and debug your entire stack.")
+    .version("0.1.0");
+program.addCommand(initCommand);
+program.addCommand(statusCommand);
+program.addCommand(healthCommand);
+program.addCommand(deployCommand);
+program.addCommand(envCommand);
+program.addCommand(logsCommand);
+program.addCommand(todoCommand);
+program.parse();

package/dist/lib/config.d.ts

@@ -0,0 +1,36 @@
+export declare const CONFIG_FILE = "stk.config.json";
+export interface ServiceConfig {
+    enabled?: boolean;
+    /** Override the default env var name for the token/url */
+    tokenEnv?: string;
+    /** Service-specific settings */
+    projectId?: string;
+    environmentId?: string;
+    serviceId?: string;
+    [key: string]: unknown;
+}
+export interface StkConfig {
+    name: string;
+    services: Record<string, boolean | ServiceConfig>;
+    deploy?: {
+        branch?: string;
+        providers?: string[];
+    };
+}
+/** All services stk knows about */
+export declare const KNOWN_SERVICES: readonly ["railway", "vercel", "fly", "render", "aws", "database", "mongodb", "redis", "supabase", "r2", "stripe"];
+export type KnownService = (typeof KNOWN_SERVICES)[number];
+/**
+ * Load config from stk.config.json in cwd or any parent directory.
+ * Falls back to auto-detecting enabled services from env vars.
+ */
+export declare function loadConfig(): StkConfig;
+/**
+ * Resolve the service config for a given service name.
+ * Returns null if the service is not enabled.
+ */
+export declare function resolveService(config: StkConfig, service: string): ServiceConfig | null;
+/**
+ * Get list of enabled service names from config.
+ */
+export declare function enabledServices(config: StkConfig): string[];

package/dist/lib/config.js

@@ -0,0 +1,102 @@
+import { readFileSync, existsSync } from "fs";
+import { resolve } from "path";
+export const CONFIG_FILE = "stk.config.json";
+const DEFAULTS = {
+    name: "my-app",
+    services: {},
+};
+/** All services stk knows about */
+export const KNOWN_SERVICES = [
+    "railway",
+    "vercel",
+    "fly",
+    "render",
+    "aws",
+    "database",
+    "mongodb",
+    "redis",
+    "supabase",
+    "r2",
+    "stripe",
+];
+/**
+ * Load config from stk.config.json in cwd or any parent directory.
+ * Falls back to auto-detecting enabled services from env vars.
+ */
+export function loadConfig() {
+    const configPath = findConfigFile();
+    if (configPath) {
+        try {
+            const raw = readFileSync(configPath, "utf-8");
+            const parsed = JSON.parse(raw);
+            return { ...DEFAULTS, ...parsed };
+        }
+        catch {
+            // Invalid JSON — fall through to auto-detect
+        }
+    }
+    // Auto-detect: enable services whose env vars are present
+    return {
+        ...DEFAULTS,
+        services: autoDetectServices(),
+    };
+}
+/**
+ * Resolve the service config for a given service name.
+ * Returns null if the service is not enabled.
+ */
+export function resolveService(config, service) {
+    const entry = config.services[service];
+    if (!entry)
+        return null;
+    if (entry === true)
+        return { enabled: true };
+    if (typeof entry === "object" && entry.enabled !== false)
+        return entry;
+    return null;
+}
+/**
+ * Get list of enabled service names from config.
+ */
+export function enabledServices(config) {
+    return Object.entries(config.services)
+        .filter(([, v]) => v === true || (typeof v === "object" && v.enabled !== false))
+        .map(([k]) => k);
+}
+/** Walk up from cwd looking for stk.config.json */
+function findConfigFile() {
+    let dir = process.cwd();
+    while (true) {
+        const candidate = resolve(dir, CONFIG_FILE);
+        if (existsSync(candidate))
+            return candidate;
+        const parent = resolve(dir, "..");
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return null;
+}
+/** Map of service → env var that indicates it's available */
+const SERVICE_ENV_MAP = {
+    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", "CLOUDFLARE_API_TOKEN"],
+    stripe: ["STRIPE_SECRET_KEY"],
+};
+function autoDetectServices() {
+    const services = {};
+    for (const [name, envVars] of Object.entries(SERVICE_ENV_MAP)) {
+        if (envVars.some((v) => process.env[v])) {
+            services[name] = true;
+        }
+    }
+    return services;
+}

package/dist/services/aws.d.ts

@@ -0,0 +1,2 @@
+import { type CheckResult } from "./checker.js";
+export declare function checkAWS(): Promise<CheckResult>;

package/dist/services/aws.js

@@ -0,0 +1,32 @@
+import { runCheck } from "./checker.js";
+export async function checkAWS() {
+    const accessKey = process.env.AWS_ACCESS_KEY_ID;
+    const secretKey = process.env.AWS_SECRET_ACCESS_KEY;
+    const region = process.env.AWS_REGION ?? "us-east-1";
+    if (!accessKey || !secretKey) {
+        return {
+            name: "AWS",
+            status: "skipped",
+            detail: "AWS_ACCESS_KEY_ID or AWS_SECRET_ACCESS_KEY not set",
+        };
+    }
+    return runCheck("AWS", async () => {
+        // Use STS GetCallerIdentity — the simplest AWS API call that works with any credentials
+        const host = `sts.${region}.amazonaws.com`;
+        const body = "Action=GetCallerIdentity&Version=2011-06-15";
+        const now = new Date();
+        // AWS Signature V4 is complex — for a lightweight check we hit the endpoint
+        // and verify we get a response (even 403 means AWS is reachable)
+        const res = await fetch(`https://${host}/`, {
+            method: "POST",
+            headers: { "Content-Type": "application/x-www-form-urlencoded" },
+            body,
+        });
+        // 403 = creds not signed but AWS is reachable
+        // 200 = would need full SigV4, which we skip for simplicity
+        if (res.status === 403 || res.ok) {
+            return { detail: `${region} — endpoint reachable` };
+        }
+        throw new Error(`HTTP ${res.status}`);
+    });
+}