@arm8tron/smart-deploy 0.1.0-beta.1

package/README.md

@@ -0,0 +1,37 @@
+# Smart Deploy CLI
+
+> Beta release: login and local project selection are available today. Smart Analysis and deployment commands are still in development.
+
+Smart Deploy is a preview-first application deployment platform. This CLI connects a local Git checkout to your Smart Deploy account.
+
+## Install or run
+
+Use Node.js 20 or later.
+
+~~~bash
+npx @arm8tron/smart-deploy@beta login
+~~~
+
+## Commands
+
+~~~text
+smart-deploy login
+smart-deploy logout
+smart-deploy init [--repo URL] [--branch NAME] [--service NAME]
+smart-deploy repo show
+smart-deploy repo use URL [--branch NAME]
+smart-deploy service select NAME
+smart-deploy config show
+~~~
+
+Login opens a browser authorization flow and uses your existing Smart Deploy GitHub connection. The CLI never receives your GitHub OAuth token.
+
+Init stores the selected repository, branch, and service in .smartdeploy/state.json, which is ignored by Git. It does not store secrets or deployment credentials in the repository.
+
+Install beta releases explicitly:
+
+~~~bash
+npx @arm8tron/smart-deploy@beta
+~~~
+
+See the [Smart Deploy repository](https://github.com/anirudh-makuluri/smart-deploy) for source, issues, and release status.

package/dist/auth.d.ts

@@ -0,0 +1,6 @@
+export declare function getApiUrl(): string;
+export declare function readCliToken(): Promise<string | null>;
+export declare function writeCliToken(token: string): Promise<void>;
+export declare function clearCliToken(): Promise<void>;
+export declare function login(): Promise<void>;
+export declare function logout(): Promise<void>;

package/dist/auth.js

@@ -0,0 +1,63 @@
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+const DEFAULT_API_URL = "https://smart-deploy.xyz";
+function credentialPath() {
+    const base = process.env.SMART_DEPLOY_CONFIG_DIR?.trim() || process.env.APPDATA || join(homedir(), ".config");
+    return join(base, "smart-deploy", "credentials.json");
+}
+export function getApiUrl() {
+    return (process.env.SMART_DEPLOY_API_URL?.trim() || DEFAULT_API_URL).replace(/\/$/, "");
+}
+export async function readCliToken() {
+    try {
+        const content = await readFile(credentialPath(), "utf8");
+        const value = JSON.parse(content);
+        return typeof value.token === "string" && value.token.trim() ? value.token.trim() : null;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        throw new Error("Smart Deploy CLI credentials are invalid. Run smart-deploy logout and log in again.");
+    }
+}
+export async function writeCliToken(token) {
+    const path = credentialPath();
+    const temporary = path + "." + process.pid + ".tmp";
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    await writeFile(temporary, JSON.stringify({ token }) + "\n", { encoding: "utf8", mode: 0o600 });
+    await rename(temporary, path);
+}
+export async function clearCliToken() {
+    await rm(credentialPath(), { force: true });
+}
+export async function login() {
+    const start = await fetch(getApiUrl() + "/api/cli/device/start", { method: "POST" });
+    if (!start.ok)
+        throw new Error("Could not begin CLI login.");
+    const request = await start.json();
+    console.log("Open this URL in a browser and approve Smart Deploy CLI:");
+    console.log(request.verificationUri);
+    const deadline = Date.now() + request.expiresIn * 1000;
+    while (Date.now() < deadline) {
+        await new Promise((resolve) => setTimeout(resolve, request.interval * 1000));
+        const response = await fetch(getApiUrl() + "/api/cli/device/token", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ deviceCode: request.deviceCode }) });
+        if (response.status === 202)
+            continue;
+        if (!response.ok)
+            throw new Error("CLI login failed.");
+        const token = await response.json();
+        if (typeof token.accessToken !== "string")
+            throw new Error("CLI login returned no access token.");
+        await writeCliToken(token.accessToken);
+        console.log("Smart Deploy CLI is connected.");
+        return;
+    }
+    throw new Error("CLI authorization expired. Run smart-deploy login again.");
+}
+export async function logout() {
+    const token = await readCliToken();
+    if (token)
+        await fetch(getApiUrl() + "/api/cli/logout", { method: "POST", headers: { Authorization: "Bearer " + token } });
+    await clearCliToken();
+}

package/dist/git.d.ts

@@ -0,0 +1,11 @@
+export type GitCommandRunner = (args: string[], workdir: string) => string;
+export type GitRepositoryContext = {
+    rootDirectory: string;
+    repoUrl: string;
+    branch: string;
+    commitSha: string;
+    isWorkingTreeClean: boolean;
+};
+export declare function normalizeGitHubRemote(remote: string): string;
+export declare const runGitCommand: GitCommandRunner;
+export declare function readGitRepositoryContext(workdir: string, runCommand?: GitCommandRunner): GitRepositoryContext;

package/dist/git.js

@@ -0,0 +1,37 @@
+import { execFileSync } from "node:child_process";
+export function normalizeGitHubRemote(remote) {
+    const trimmed = remote.trim();
+    const sshMatch = trimmed.match(/^git@github\.com:([^/\s]+)\/([^/\s]+?)(?:\.git)?\/?$/i);
+    const httpsMatch = trimmed.match(/^https:\/\/github\.com\/([^/\s]+)\/([^/\s]+?)(?:\.git)?\/?$/i);
+    const match = sshMatch ?? httpsMatch;
+    if (!match) {
+        throw new Error("Smart Deploy currently requires a GitHub origin remote.");
+    }
+    return `https://github.com/${match[1]}/${match[2]}`;
+}
+export const runGitCommand = (args, workdir) => execFileSync("git", args, { cwd: workdir, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+export function readGitRepositoryContext(workdir, runCommand = runGitCommand) {
+    try {
+        const rootDirectory = runCommand(["rev-parse", "--show-toplevel"], workdir);
+        const remote = runCommand(["config", "--get", "remote.origin.url"], rootDirectory);
+        const branch = runCommand(["branch", "--show-current"], rootDirectory);
+        const commitSha = runCommand(["rev-parse", "HEAD"], rootDirectory);
+        const workingTreeStatus = runCommand(["status", "--porcelain"], rootDirectory);
+        if (!branch)
+            throw new Error("Smart Deploy cannot initialize from a detached Git HEAD.");
+        if (!commitSha)
+            throw new Error("Smart Deploy could not resolve the current Git commit.");
+        return {
+            rootDirectory,
+            repoUrl: normalizeGitHubRemote(remote),
+            branch,
+            commitSha,
+            isWorkingTreeClean: !workingTreeStatus,
+        };
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.startsWith("Smart Deploy"))
+            throw error;
+        throw new Error("Smart Deploy must run inside a Git repository with an origin remote.");
+    }
+}

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,116 @@
+#!/usr/bin/env node
+import { cwd, stdin, stdout } from "node:process";
+import { createInterface } from "node:readline/promises";
+import { normalizeGitHubRemote, readGitRepositoryContext } from "./git.js";
+import { readProjectState, writeProjectState } from "./state.js";
+import { login, logout } from "./auth.js";
+function parseArguments(args) {
+    const positionals = [];
+    const options = new Map();
+    for (let index = 0; index < args.length; index += 1) {
+        const current = args[index];
+        if (!current.startsWith("--")) {
+            positionals.push(current);
+            continue;
+        }
+        const [name, inlineValue] = current.slice(2).split("=", 2);
+        const nextValue = inlineValue ?? args[index + 1];
+        if (!name || !nextValue || nextValue.startsWith("--")) {
+            throw new Error(`Option --${name || current} requires a value.`);
+        }
+        options.set(name, nextValue);
+        if (inlineValue === undefined)
+            index += 1;
+    }
+    return { positionals, options };
+}
+async function ask(question, defaultValue) {
+    const prompt = createInterface({ input: stdin, output: stdout });
+    try {
+        const answer = (await prompt.question(`${question} [${defaultValue}]: `)).trim();
+        return answer || defaultValue;
+    }
+    finally {
+        prompt.close();
+    }
+}
+function printHelp() {
+    console.log(`Smart Deploy CLI
+
+Usage:
+  smart-deploy init [--repo URL] [--branch NAME] [--service NAME]
+  smart-deploy login | logout
+  smart-deploy repo show
+  smart-deploy repo use URL [--branch NAME]
+  smart-deploy service select NAME
+  smart-deploy config show
+
+The current foundation stores only repository, branch, and service selection locally. Analysis, domain, secrets, and deployment commands follow in the next slice.`);
+}
+async function initialize(options) {
+    const context = readGitRepositoryContext(cwd());
+    const repoUrl = normalizeGitHubRemote(options.get("repo") ?? await ask("Repository URL", context.repoUrl));
+    const branch = options.get("branch") ?? await ask("Branch", context.branch);
+    const serviceName = options.get("service") ?? null;
+    const state = { version: 1, repoUrl, branch, serviceName };
+    await writeProjectState(context.rootDirectory, state);
+    console.log(`Saved Smart Deploy project selection in ${context.rootDirectory}\\.smartdeploy\\state.json`);
+    console.log(`Repository: ${repoUrl}\nBranch: ${branch}\nService: ${serviceName ?? "not selected"}`);
+    if (!context.isWorkingTreeClean) {
+        console.log("\nNote: your working tree has uncommitted changes. Analysis and deploy will require a pushed commit.");
+    }
+}
+async function showConfig() {
+    const context = readGitRepositoryContext(cwd());
+    const state = await readProjectState(context.rootDirectory);
+    if (!state)
+        throw new Error("No Smart Deploy project selection found. Run smart-deploy init first.");
+    console.log(JSON.stringify(state, null, 2));
+}
+async function selectRepository(positionals, options) {
+    const repoUrlInput = positionals[2]?.trim();
+    if (!repoUrlInput)
+        throw new Error("Usage: smart-deploy repo use <repository-url> [--branch NAME]");
+    const repoUrl = normalizeGitHubRemote(repoUrlInput);
+    const context = readGitRepositoryContext(cwd());
+    const current = await readProjectState(context.rootDirectory);
+    const branch = options.get("branch") ?? current?.branch ?? context.branch;
+    await writeProjectState(context.rootDirectory, { version: 1, repoUrl, branch, serviceName: null });
+    console.log(`Selected repository ${repoUrl} on ${branch}. Choose a service with smart-deploy service select <name>.`);
+}
+async function selectService(positionals) {
+    const serviceName = positionals[2]?.trim();
+    if (!serviceName)
+        throw new Error("Usage: smart-deploy service select <name>");
+    const context = readGitRepositoryContext(cwd());
+    const current = await readProjectState(context.rootDirectory);
+    if (!current)
+        throw new Error("No Smart Deploy project selection found. Run smart-deploy init first.");
+    await writeProjectState(context.rootDirectory, { ...current, serviceName });
+    console.log(`Selected service ${serviceName}.`);
+}
+async function main() {
+    const { positionals, options } = parseArguments(process.argv.slice(2));
+    const [command, subcommand] = positionals;
+    if (!command || command === "help" || command === "--help")
+        return printHelp();
+    if (command === "login")
+        return login();
+    if (command === "logout")
+        return logout();
+    if (command === "init")
+        return initialize(options);
+    if (command === "config" && subcommand === "show")
+        return showConfig();
+    if (command === "repo" && subcommand === "show")
+        return showConfig();
+    if (command === "repo" && subcommand === "use")
+        return selectRepository(positionals, options);
+    if (command === "service" && subcommand === "select")
+        return selectService(positionals);
+    throw new Error(`Unknown command: ${positionals.join(" ")}`);
+}
+void main().catch((error) => {
+    console.error(error instanceof Error ? error.message : "Smart Deploy command failed.");
+    process.exitCode = 1;
+});

package/dist/state.d.ts

@@ -0,0 +1,11 @@
+export declare const PROJECT_STATE_DIRECTORY = ".smartdeploy";
+export declare const PROJECT_STATE_FILE = "state.json";
+export type ProjectState = {
+    version: 1;
+    repoUrl: string;
+    branch: string;
+    serviceName: string | null;
+};
+export declare function getProjectStatePath(workdir: string): string;
+export declare function readProjectState(workdir: string): Promise<ProjectState | null>;
+export declare function writeProjectState(workdir: string, state: ProjectState): Promise<void>;

package/dist/state.js

@@ -0,0 +1,49 @@
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+export const PROJECT_STATE_DIRECTORY = ".smartdeploy";
+export const PROJECT_STATE_FILE = "state.json";
+function asNonEmptyString(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function parseProjectState(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error("Smart Deploy state must be an object.");
+    }
+    const state = value;
+    const repoUrl = asNonEmptyString(state.repoUrl);
+    const branch = asNonEmptyString(state.branch);
+    const serviceName = state.serviceName === null ? null : asNonEmptyString(state.serviceName);
+    if (state.version !== 1 || !repoUrl || !branch || (state.serviceName !== null && !serviceName)) {
+        throw new Error("Smart Deploy state is invalid. Run `smart-deploy init` again.");
+    }
+    return { version: 1, repoUrl, branch, serviceName };
+}
+export function getProjectStatePath(workdir) {
+    return join(workdir, PROJECT_STATE_DIRECTORY, PROJECT_STATE_FILE);
+}
+export async function readProjectState(workdir) {
+    const statePath = getProjectStatePath(workdir);
+    try {
+        const content = await readFile(statePath, "utf8");
+        return parseProjectState(JSON.parse(content));
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        if (error instanceof SyntaxError) {
+            throw new Error("Smart Deploy state is not valid JSON. Run `smart-deploy init` again.");
+        }
+        throw error;
+    }
+}
+export async function writeProjectState(workdir, state) {
+    const directory = join(workdir, PROJECT_STATE_DIRECTORY);
+    const statePath = getProjectStatePath(workdir);
+    const temporaryPath = `${statePath}.${process.pid}.tmp`;
+    await mkdir(directory, { recursive: true, mode: 0o700 });
+    await writeFile(temporaryPath, `${JSON.stringify(parseProjectState(state), null, 2)}\n`, {
+        encoding: "utf8",
+        mode: 0o600,
+    });
+    await rename(temporaryPath, statePath);
+}

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@arm8tron/smart-deploy",
+  "version": "0.1.0-beta.1",
+  "description": "Command-line interface for Smart Deploy",
+  "type": "module",
+  "bin": { "smart-deploy": "./dist/index.js" },
+  "files": ["dist", "README.md"],
+  "publishConfig": { "access": "public", "tag": "beta" },
+  "scripts": { "build": "tsc -p tsconfig.json", "prepack": "npm run build", "pack:dry-run": "npm pack --dry-run" },
+  "engines": { "node": ">=20" },
+  "keywords": ["smart-deploy", "deployment", "cli", "aws"],
+  "license": "Apache-2.0",
+  "homepage": "https://smart-deploy.xyz",
+  "repository": { "type": "git", "url": "git+https://github.com/anirudh-makuluri/smart-deploy.git", "directory": "packages/cli" },
+  "bugs": { "url": "https://github.com/anirudh-makuluri/smart-deploy/issues" },
+  "devDependencies": { "@types/node": "^20.19.0", "typescript": "^5.0.0" }
+}