@vibeshiphq/cli 0.1.0

package/README.md

@@ -0,0 +1,72 @@
+# VibeShip CLI
+
+Public CLI for initializing the private VibeShip starter and installing VibeShip Pilot for guided setup.
+
+```bash
+npm install -g @vibeshiphq/cli
+vibeship login
+vibeship init my-app
+cd my-app
+vibeship pilot install
+```
+
+The CLI does not embed proprietary setup runbooks. It authenticates the user, checks starter/Pilot entitlement through VibeShip, clones the private starter, and writes local Codex MCP config for Pilot.
+
+## Commands
+
+```bash
+vibeship login                    # Authenticate this machine with VibeShip
+vibeship logout                   # Remove local CLI auth
+vibeship whoami                   # Show account and entitlement status
+vibeship doctor                   # Inspect auth, project, and Pilot config
+vibeship init [targetDir]         # Clone the private starter into a new app
+vibeship pilot install            # Install Pilot MCP config into .codex/config.toml
+vibeship pilot status             # Show Pilot subscription and project config status
+```
+
+Configuration is stored at `~/.vibeship/config.json`. The default production API is `https://www.vibeship.today`; override it with `VIBESHIP_API_URL` or `--api-url` when dogfooding against a local internal app.
+
+Pilot MCP defaults to `https://pilot.vibeship.today/mcp`; override it with `VIBESHIP_PILOT_MCP_URL` or `--mcp-url`.
+
+## Development
+
+```bash
+pnpm install
+pnpm check
+pnpm dev -- --help
+```
+
+## Local Dogfooding
+
+Run the internal app first:
+
+```bash
+cd ~/projects/vibeship-workspace/internal
+pnpm dev
+```
+
+Then log in from the CLI repo:
+
+```bash
+cd ~/projects/vibeship-workspace/cli
+pnpm dev login
+```
+
+When invoked through the `dev` script, the CLI uses `http://localhost:3000` as the VibeShip API URL. A built CLI uses production defaults.
+
+For offline CLI UI work:
+
+```bash
+VIBESHIP_CLI_OFFLINE=1 pnpm dev -- whoami
+```
+
+## Publishing
+
+Before publishing:
+
+```bash
+pnpm check
+npm pack --dry-run
+```
+
+The package publishes only `dist` and this README. `prepack` runs a clean TypeScript build so stale local artifacts are not included.

package/dist/api.d.ts

@@ -0,0 +1,11 @@
+import type { AuthState } from "./config.js";
+export type EntitlementStatus = {
+    email?: string;
+    starterAccess: boolean;
+    pilotActive: boolean;
+    entitlements: string[];
+};
+export declare function fetchEntitlements({ apiUrl, auth, }: {
+    apiUrl: string;
+    auth: AuthState;
+}): Promise<EntitlementStatus>;

package/dist/api.js

@@ -0,0 +1,44 @@
+export async function fetchEntitlements({ apiUrl, auth, }) {
+    if (process.env.VIBESHIP_CLI_OFFLINE === "1") {
+        return {
+            email: auth.email,
+            starterAccess: true,
+            pilotActive: true,
+            entitlements: ["license:starter", "pilot:active"],
+        };
+    }
+    const url = new URL("/api/cli/entitlements", apiUrl);
+    let response;
+    try {
+        response = await fetch(url, {
+            method: "POST",
+            headers: {
+                authorization: `Bearer ${auth.token}`,
+                "content-type": "application/json",
+            },
+            body: JSON.stringify({}),
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Could not reach VibeShip at ${url.origin}: ${message}`);
+    }
+    if (!response.ok) {
+        throw new Error(`Entitlement check failed with HTTP ${response.status}${await responseSuffix(response)}.`);
+    }
+    return (await response.json());
+}
+async function responseSuffix(response) {
+    const text = (await response.text()).trim();
+    if (!text) {
+        return "";
+    }
+    try {
+        const json = JSON.parse(text);
+        const message = json.error ?? json.message;
+        return typeof message === "string" ? `: ${message}` : "";
+    }
+    catch {
+        return `: ${text.slice(0, 180)}`;
+    }
+}

package/dist/codex.d.ts

@@ -0,0 +1,8 @@
+export declare function projectCodexConfigPath(projectDir: string): string;
+export declare function pilotCodexConfig({ mcpUrl, }: {
+    mcpUrl: string;
+}): string;
+export declare function installPilotCodexConfig({ projectDir, mcpUrl, }: {
+    projectDir: string;
+    mcpUrl: string;
+}): string;

package/dist/codex.js

@@ -0,0 +1,25 @@
+import fs from "node:fs";
+import path from "node:path";
+export function projectCodexConfigPath(projectDir) {
+    return path.join(projectDir, ".codex", "config.toml");
+}
+export function pilotCodexConfig({ mcpUrl, }) {
+    return `[mcp_servers.vibeship-pilot]
+url = "${mcpUrl}"
+bearer_token_env_var = "VIBESHIP_PILOT_TOKEN"
+default_tools_approval_mode = "prompt"
+`;
+}
+export function installPilotCodexConfig({ projectDir, mcpUrl, }) {
+    const file = projectCodexConfigPath(projectDir);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const existing = fs.existsSync(file) ? fs.readFileSync(file, "utf8") : "";
+    const marker = "[mcp_servers.vibeship-pilot]";
+    const next = existing.includes(marker)
+        ? existing.replace(/\[mcp_servers\.vibeship-pilot\][\s\S]*?(?=\n\[|$)/, pilotCodexConfig({ mcpUrl }).trimEnd())
+        : `${existing.trimEnd()}${existing.trim() ? "\n\n" : ""}${pilotCodexConfig({
+            mcpUrl,
+        }).trimEnd()}\n`;
+    fs.writeFileSync(file, next);
+    return file;
+}

package/dist/config.d.ts

@@ -0,0 +1,22 @@
+import { z } from "zod";
+declare const authStateSchema: z.ZodObject<{
+    token: z.ZodString;
+    email: z.ZodOptional<z.ZodString>;
+    clerkUserId: z.ZodOptional<z.ZodString>;
+    expiresAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type AuthState = z.infer<typeof authStateSchema>;
+export type CliConfig = {
+    auth?: AuthState;
+    apiUrl?: string;
+    pilotMcpUrl?: string;
+};
+export declare function configDir(): string;
+export declare function configPath(): string;
+export declare function readConfig(): CliConfig;
+export declare function writeConfig(config: CliConfig): void;
+export declare function clearAuth(): void;
+export declare function requireAuth(config?: CliConfig): AuthState;
+export declare function defaultApiUrl(): string;
+export declare function defaultPilotMcpUrl(): string;
+export {};

package/dist/config.js

@@ -0,0 +1,57 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { z } from "zod";
+const authStateSchema = z.object({
+    token: z.string().min(1),
+    email: z.string().email().optional(),
+    clerkUserId: z.string().optional(),
+    expiresAt: z.string().optional(),
+});
+const configSchema = z.object({
+    auth: authStateSchema.optional(),
+    apiUrl: z.string().url().optional(),
+    pilotMcpUrl: z.string().url().optional(),
+});
+export function configDir() {
+    return path.join(os.homedir(), ".vibeship");
+}
+export function configPath() {
+    return path.join(configDir(), "config.json");
+}
+export function readConfig() {
+    const file = configPath();
+    if (!fs.existsSync(file)) {
+        return {};
+    }
+    return configSchema.parse(JSON.parse(fs.readFileSync(file, "utf8")));
+}
+export function writeConfig(config) {
+    fs.mkdirSync(configDir(), { recursive: true, mode: 0o700 });
+    fs.writeFileSync(configPath(), `${JSON.stringify(config, null, 2)}\n`, {
+        mode: 0o600,
+    });
+}
+export function clearAuth() {
+    const current = readConfig();
+    delete current.auth;
+    writeConfig(current);
+}
+export function requireAuth(config = readConfig()) {
+    if (!config.auth?.token) {
+        throw new Error("Run `vibeship login` before using this command.");
+    }
+    return config.auth;
+}
+export function defaultApiUrl() {
+    if (process.env.VIBESHIP_API_URL) {
+        return process.env.VIBESHIP_API_URL;
+    }
+    if (process.env.npm_lifecycle_event === "dev") {
+        return "http://localhost:3000";
+    }
+    return "https://www.vibeship.today";
+}
+export function defaultPilotMcpUrl() {
+    return process.env.VIBESHIP_PILOT_MCP_URL ?? "https://pilot.vibeship.today/mcp";
+}

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+import { run } from "./program.js";
+import { renderError } from "./ui.js";
+run(process.argv).catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    renderError("VibeShip CLI failed", message, recoveryActions(message));
+    process.exitCode = 1;
+});
+function recoveryActions(message) {
+    if (message.includes("Run `vibeship login`")) {
+        return ["vibeship login"];
+    }
+    if (message.includes("starter access")) {
+        return [
+            "Confirm this account has starter access at https://www.vibeship.today.",
+            "Then run vibeship login again.",
+        ];
+    }
+    if (message.includes("Pilot subscription")) {
+        return [
+            "Confirm this account has an active Pilot subscription at https://www.vibeship.today.",
+            "Then run vibeship login again.",
+        ];
+    }
+    if (message.includes("Could not reach VibeShip")) {
+        return [
+            "Check your network connection.",
+            "Use --api-url or VIBESHIP_API_URL if you are targeting a local app.",
+        ];
+    }
+    if (message.includes("HTTP 401") || message.includes("HTTP 403")) {
+        return ["vibeship login", "vibeship whoami"];
+    }
+    if (message.includes("already exists and is not empty")) {
+        return ["Choose a new directory: vibeship init my-app"];
+    }
+    return ["Run with --help to inspect command options."];
+}

package/dist/login.d.ts

@@ -0,0 +1,19 @@
+export type BrowserLoginResult = {
+    token: string;
+    email?: string;
+    expiresAt?: string;
+};
+export type BrowserLoginSession = {
+    loginUrl: string;
+    waitForResult: Promise<BrowserLoginResult>;
+    close: () => Promise<void>;
+};
+export declare function createCliLoginUrl({ apiUrl, redirectUri, state, }: {
+    apiUrl: string;
+    redirectUri: string;
+    state: string;
+}): string;
+export declare function startBrowserLogin({ apiUrl, timeoutMs, }: {
+    apiUrl: string;
+    timeoutMs?: number;
+}): Promise<BrowserLoginSession>;

package/dist/login.js

@@ -0,0 +1,71 @@
+import crypto from "node:crypto";
+import http from "node:http";
+export function createCliLoginUrl({ apiUrl, redirectUri, state, }) {
+    const url = new URL("/cli/login", apiUrl);
+    url.searchParams.set("redirect_uri", redirectUri);
+    url.searchParams.set("state", state);
+    return url.toString();
+}
+function html(message) {
+    return `<!doctype html><html><head><meta charset="utf-8"><title>VibeShip CLI</title></head><body><main style="font-family: system-ui, sans-serif; max-width: 42rem; margin: 4rem auto;"><h1>${message}</h1><p>You can return to your terminal.</p></main></body></html>`;
+}
+function writeHtml(response, statusCode, message) {
+    response.writeHead(statusCode, { "content-type": "text/html; charset=utf-8" });
+    response.end(html(message));
+}
+export async function startBrowserLogin({ apiUrl, timeoutMs = 120_000, }) {
+    const state = crypto.randomBytes(24).toString("base64url");
+    let settle;
+    const waitForResult = new Promise((resolve, reject) => {
+        settle = { resolve, reject };
+    });
+    const server = http.createServer((request, response) => {
+        const requestUrl = new URL(request.url ?? "/", "http://127.0.0.1");
+        if (requestUrl.pathname !== "/callback") {
+            writeHtml(response, 404, "Unknown VibeShip CLI callback");
+            return;
+        }
+        if (requestUrl.searchParams.get("state") !== state) {
+            writeHtml(response, 400, "Invalid VibeShip CLI login state");
+            settle?.reject(new Error("CLI login returned an invalid state."));
+            return;
+        }
+        const token = requestUrl.searchParams.get("token");
+        if (!token) {
+            writeHtml(response, 400, "VibeShip CLI login did not return a token");
+            settle?.reject(new Error("CLI login did not return a token."));
+            return;
+        }
+        writeHtml(response, 200, "VibeShip CLI login complete");
+        settle?.resolve({
+            token,
+            email: requestUrl.searchParams.get("email") ?? undefined,
+            expiresAt: requestUrl.searchParams.get("expires_at") ?? undefined,
+        });
+    });
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(0, "127.0.0.1", () => resolve());
+    });
+    const address = server.address();
+    const redirectUri = `http://127.0.0.1:${address.port}/callback`;
+    const timeout = setTimeout(() => {
+        settle?.reject(new Error("Timed out waiting for browser login."));
+        void closeServer(server);
+    }, timeoutMs);
+    waitForResult.finally(() => clearTimeout(timeout)).catch(() => undefined);
+    return {
+        loginUrl: createCliLoginUrl({ apiUrl, redirectUri, state }),
+        waitForResult,
+        close: () => closeServer(server),
+    };
+}
+function closeServer(server) {
+    return new Promise((resolve, reject) => {
+        if (!server.listening) {
+            resolve();
+            return;
+        }
+        server.close((error) => (error ? reject(error) : resolve()));
+    });
+}

package/dist/program.d.ts

@@ -0,0 +1,2 @@
+export declare function run(argv: string[]): Promise<void>;
+export declare function normalizeArgv(argv: string[]): string[];

package/dist/program.js

@@ -0,0 +1,256 @@
+import fs from "node:fs";
+import path from "node:path";
+import { Command } from "commander";
+import { execa } from "execa";
+import open from "open";
+import { fetchEntitlements } from "./api.js";
+import { clearAuth, defaultApiUrl, defaultPilotMcpUrl, readConfig, requireAuth, writeConfig, } from "./config.js";
+import { installPilotCodexConfig } from "./codex.js";
+import { startBrowserLogin } from "./login.js";
+import { line, renderDone, renderInfo } from "./ui.js";
+const STARTER_REPO = "git@github.com:vibeshiphq/vibeship-starter.git";
+async function commandLogin(options) {
+    const config = readConfig();
+    const apiUrl = options.apiUrl ?? config.apiUrl ?? defaultApiUrl();
+    if (!options.token) {
+        const login = await startBrowserLogin({ apiUrl });
+        renderInfo("Browser login", [
+            line("api", apiUrl),
+            line("callback", "listening on 127.0.0.1"),
+        ]);
+        try {
+            await open(login.loginUrl);
+        }
+        catch {
+            renderInfo("Open this URL", [line("url", login.loginUrl)], ["Complete the browser flow to return a CLI token."]);
+        }
+        const result = await login.waitForResult.finally(() => login.close());
+        writeConfig({
+            ...config,
+            apiUrl,
+            auth: {
+                token: result.token,
+                email: result.email ?? options.email,
+                expiresAt: result.expiresAt,
+            },
+        });
+        renderDone("Logged in", [
+            line("config", "~/.vibeship/config.json"),
+            line("api", apiUrl),
+            line("email", result.email ?? options.email ?? "unknown"),
+            line("expires", result.expiresAt ?? "unknown", "muted"),
+        ]);
+        return;
+    }
+    writeConfig({
+        ...config,
+        apiUrl,
+        auth: {
+            token: options.token,
+            email: options.email,
+        },
+    });
+    renderDone("Logged in", [
+        line("config", "~/.vibeship/config.json"),
+        line("api", apiUrl),
+    ]);
+}
+async function commandWhoami(options = {}) {
+    const config = readConfig();
+    const auth = requireAuth(config);
+    const apiUrl = options.apiUrl ?? config.apiUrl ?? defaultApiUrl();
+    const status = await fetchEntitlements({
+        apiUrl,
+        auth,
+    });
+    renderDone("Account", [
+        line("email", status.email ?? auth.email ?? "unknown"),
+        line("api", apiUrl, "muted"),
+        line("starter", status.starterAccess ? "ready" : "missing", status.starterAccess ? "success" : "warning"),
+        line("pilot", status.pilotActive ? "active" : "inactive", status.pilotActive ? "success" : "warning"),
+    ]);
+}
+async function commandDoctor(options) {
+    const config = readConfig();
+    const projectDir = path.resolve(options.projectDir ?? process.cwd());
+    const marker = path.join(projectDir, ".vibeship", "project.json");
+    const codexConfig = path.join(projectDir, ".codex", "config.toml");
+    const hasAuth = Boolean(config.auth?.token);
+    const hasProject = fs.existsSync(marker);
+    const hasPilotConfig = fs.existsSync(codexConfig);
+    renderInfo("Doctor", [
+        line("auth", hasAuth ? "present" : "missing", hasAuth ? "success" : "warning"),
+        line("api", options.apiUrl ?? config.apiUrl ?? defaultApiUrl(), "muted"),
+        line("project", hasProject ? "vibeship starter" : "not detected", hasProject ? "success" : "warning"),
+        line("pilot config", hasPilotConfig ? codexConfig : "not installed", hasPilotConfig ? "success" : "warning"),
+    ], doctorActions({ hasAuth, hasProject, hasPilotConfig, projectDir }));
+}
+async function cloneStarter({ targetDir, localStarter, }) {
+    if (fs.existsSync(targetDir) && fs.readdirSync(targetDir).length > 0) {
+        throw new Error(`${targetDir} already exists and is not empty.`);
+    }
+    if (localStarter) {
+        await execa("cp", ["-R", `${path.resolve(localStarter)}/.`, targetDir]);
+        return;
+    }
+    await execa("git", ["clone", STARTER_REPO, targetDir]);
+}
+async function commandInit(options) {
+    const config = readConfig();
+    const auth = requireAuth(config);
+    const apiUrl = options.apiUrl ?? config.apiUrl ?? defaultApiUrl();
+    const status = await fetchEntitlements({
+        apiUrl,
+        auth,
+    });
+    if (!status.starterAccess) {
+        throw new Error("This account does not have VibeShip starter access.");
+    }
+    const targetDir = path.resolve(options.dir ?? options.targetDir ?? "vibeship-app");
+    renderInfo("Initializing starter", [
+        line("directory", targetDir),
+        line("source", options.localStarter ? path.resolve(options.localStarter) : STARTER_REPO),
+        line("install", options.skipInstall ? "skipped" : "pnpm install"),
+    ]);
+    await cloneStarter({ targetDir, localStarter: options.localStarter });
+    if (!options.skipInstall) {
+        await execa("pnpm", ["install"], { cwd: targetDir, stdio: "inherit" });
+    }
+    renderDone("Starter initialized", [line("directory", targetDir)], [`cd ${targetDir}`, "vibeship pilot install"]);
+}
+async function commandPilotInstall(options) {
+    const config = readConfig();
+    const auth = requireAuth(config);
+    const apiUrl = options.apiUrl ?? config.apiUrl ?? defaultApiUrl();
+    const status = await fetchEntitlements({
+        apiUrl,
+        auth,
+    });
+    if (!status.pilotActive) {
+        throw new Error("This account does not have an active VibeShip Pilot subscription.");
+    }
+    const projectDir = path.resolve(options.projectDir ?? process.cwd());
+    const mcpUrl = options.mcpUrl ?? config.pilotMcpUrl ?? defaultPilotMcpUrl();
+    const file = installPilotCodexConfig({ projectDir, mcpUrl });
+    renderDone("Pilot installed", [
+        line("project", projectDir),
+        line("config", file),
+        line("mcp", mcpUrl),
+    ], [
+        "export VIBESHIP_PILOT_TOKEN=$(vibeship whoami --token-only)",
+        "Open Codex in this project and use VibeShip Pilot.",
+    ]);
+}
+async function commandPilotStatus(options) {
+    const config = readConfig();
+    const auth = requireAuth(config);
+    const apiUrl = options.apiUrl ?? config.apiUrl ?? defaultApiUrl();
+    const status = await fetchEntitlements({
+        apiUrl,
+        auth,
+    });
+    const projectDir = path.resolve(options.projectDir ?? process.cwd());
+    const codexConfig = path.join(projectDir, ".codex", "config.toml");
+    const hasPilotConfig = fs.existsSync(codexConfig);
+    renderDone("Pilot status", [
+        line("subscription", status.pilotActive ? "active" : "inactive", status.pilotActive ? "success" : "warning"),
+        line("project", projectDir),
+        line("config", hasPilotConfig ? codexConfig : "missing", hasPilotConfig ? "success" : "warning"),
+    ]);
+}
+export async function run(argv) {
+    const program = new Command();
+    program
+        .name("vibeship")
+        .description("Initialize VibeShip starter apps and install VibeShip Pilot.")
+        .version("0.1.0")
+        .showHelpAfterError()
+        .showSuggestionAfterError()
+        .configureHelp({ sortSubcommands: true })
+        .addHelpText("after", `
+Examples:
+  $ vibeship login
+  $ vibeship init my-app
+  $ vibeship pilot install --project-dir ./my-app
+  $ vibeship doctor
+
+Environment:
+  VIBESHIP_API_URL            Override the VibeShip API URL.
+  VIBESHIP_PILOT_MCP_URL      Override the Pilot MCP URL.
+  VIBESHIP_CLI_OFFLINE=1      Use local entitlement fixtures for development.
+`);
+    program
+        .command("login")
+        .description("Authenticate this machine with VibeShip.")
+        .option("--token <token>", "CLI token issued by VibeShip")
+        .option("--email <email>", "Email to store with a development token")
+        .option("--api-url <url>", "VibeShip API URL")
+        .action(commandLogin);
+    program.command("logout").action(() => {
+        clearAuth();
+        renderDone("Logged out", [line("config", "~/.vibeship/config.json")]);
+    });
+    program
+        .command("whoami")
+        .description("Show the current VibeShip account and entitlement status.")
+        .option("--token-only", "Print the stored CLI token only")
+        .option("--api-url <url>", "VibeShip API URL")
+        .action((options) => {
+        if (options.tokenOnly) {
+            process.stdout.write(`${requireAuth(readConfig()).token}\n`);
+            return;
+        }
+        return commandWhoami(options);
+    });
+    program
+        .command("doctor")
+        .description("Inspect auth, project, and Pilot config for this directory.")
+        .option("--project-dir <dir>", "Project directory", process.cwd())
+        .option("--api-url <url>", "VibeShip API URL")
+        .action(commandDoctor);
+    program
+        .command("init [targetDir]")
+        .description("Clone the private starter into a new app directory.")
+        .option("--dir <dir>", "Target directory")
+        .option("--local-starter <dir>", "Use a local starter checkout")
+        .option("--skip-install", "Skip pnpm install")
+        .option("--api-url <url>", "VibeShip API URL")
+        .action((targetDir, options) => commandInit({ ...options, targetDir }));
+    const pilot = program.command("pilot").description("Manage VibeShip Pilot setup.");
+    pilot
+        .command("install")
+        .description("Install Pilot MCP config into a Codex project.")
+        .option("--project-dir <dir>", "Project directory", process.cwd())
+        .option("--mcp-url <url>", "Pilot MCP URL")
+        .option("--api-url <url>", "VibeShip API URL")
+        .action(commandPilotInstall);
+    pilot
+        .command("status")
+        .description("Show Pilot subscription and project config status.")
+        .option("--project-dir <dir>", "Project directory", process.cwd())
+        .option("--api-url <url>", "VibeShip API URL")
+        .action(commandPilotStatus);
+    await program.parseAsync(normalizeArgv(argv));
+}
+export function normalizeArgv(argv) {
+    const [runtime, script, ...args] = argv;
+    if (args[0] === "--") {
+        return [runtime, script, ...args.slice(1)];
+    }
+    return argv;
+}
+function doctorActions({ hasAuth, hasProject, hasPilotConfig, projectDir, }) {
+    const actions = [];
+    if (!hasAuth) {
+        actions.push("vibeship login");
+    }
+    if (!hasProject) {
+        actions.push("Run from a starter app, or create one with vibeship init my-app.");
+    }
+    if (!hasPilotConfig) {
+        actions.push(projectDir === process.cwd()
+            ? "vibeship pilot install"
+            : `vibeship pilot install --project-dir ${projectDir}`);
+    }
+    return actions;
+}

package/dist/ui.d.ts

@@ -0,0 +1,30 @@
+import React from "react";
+export type DetailTone = "default" | "success" | "warning" | "danger" | "muted";
+export type DetailLine = {
+    label: string;
+    value: string;
+    tone?: DetailTone;
+};
+type PanelProps = {
+    title: string;
+    subtitle?: string;
+    details?: DetailLine[];
+    actions?: string[];
+    tone?: DetailTone;
+};
+export declare function line(label: string, value: string, tone?: DetailTone): DetailLine;
+export declare function Logo({ subtitle }: {
+    subtitle?: string;
+}): React.JSX.Element;
+export declare function StatusLine({ label, value, tone, }: {
+    label: string;
+    value: string;
+    tone?: DetailTone;
+}): React.JSX.Element;
+export declare function Panel({ title, subtitle, details, actions, tone, }: PanelProps): React.JSX.Element;
+export declare function renderPanel(props: PanelProps): void;
+export declare function renderDone(title: string, details: DetailLine[] | Array<[string, string]>, actions?: string[]): void;
+export declare function renderInfo(title: string, details?: DetailLine[] | Array<[string, string]>, actions?: string[]): void;
+export declare function renderError(title: string, message: string, actions?: string[]): void;
+export declare function normalizeDetails(details: DetailLine[] | Array<[string, string]>): DetailLine[];
+export {};

package/dist/ui.js

@@ -0,0 +1,55 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text, render } from "ink";
+const toneColor = {
+    default: undefined,
+    success: "green",
+    warning: "yellow",
+    danger: "red",
+    muted: "gray",
+};
+export function line(label, value, tone = "default") {
+    return { label, value, tone };
+}
+export function Logo({ subtitle }) {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "cyanBright", bold: true, children: "VibeShip" }), subtitle ? _jsx(Text, { color: "gray", children: subtitle }) : null] }));
+}
+export function StatusLine({ label, value, tone, }) {
+    return (_jsxs(Text, { children: [_jsxs(Text, { color: "gray", children: [label.padEnd(14), " "] }), _jsx(Text, { color: toneColor[tone ?? "default"], children: value })] }));
+}
+export function Panel({ title, subtitle, details = [], actions = [], tone = "default", }) {
+    const titleColor = toneColor[tone] ?? "white";
+    return (_jsxs(Box, { flexDirection: "column", paddingY: 1, children: [_jsx(Logo, { subtitle: subtitle }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { color: titleColor, bold: true, children: title }), details.map((detail) => (_jsx(StatusLine, { label: detail.label, value: detail.value, tone: detail.tone }, detail.label))), actions.length > 0 ? (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { color: "gray", children: "Next steps" }), actions.map((action) => (_jsx(Text, { children: action }, action)))] })) : null] })] }));
+}
+export function renderPanel(props) {
+    const instance = render(_jsx(Panel, { title: props.title, subtitle: props.subtitle, details: props.details, actions: props.actions, tone: props.tone }));
+    instance.unmount();
+}
+export function renderDone(title, details, actions = []) {
+    renderPanel({
+        title,
+        subtitle: "Command complete",
+        details: normalizeDetails(details),
+        actions,
+        tone: "success",
+    });
+}
+export function renderInfo(title, details = [], actions = []) {
+    renderPanel({
+        title,
+        subtitle: "Working",
+        details: normalizeDetails(details),
+        actions,
+    });
+}
+export function renderError(title, message, actions = []) {
+    renderPanel({
+        title,
+        subtitle: "Command failed",
+        details: [line("error", message, "danger")],
+        actions,
+        tone: "danger",
+    });
+}
+export function normalizeDetails(details) {
+    return details.map((detail) => Array.isArray(detail) ? line(detail[0], detail[1]) : detail);
+}

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@vibeshiphq/cli",
+  "version": "0.1.0",
+  "description": "VibeShip CLI for starter initialization and Pilot setup.",
+  "type": "module",
+  "license": "UNLICENSED",
+  "homepage": "https://www.vibeship.today",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/vibeshiphq/vibeship-cli.git"
+  },
+  "bugs": {
+    "url": "https://github.com/vibeshiphq/vibeship-cli/issues"
+  },
+  "keywords": [
+    "vibeship",
+    "cli",
+    "starter",
+    "codex",
+    "mcp"
+  ],
+  "packageManager": "pnpm@9.15.0",
+  "main": "dist/index.js",
+  "exports": "./dist/index.js",
+  "bin": {
+    "vibeship": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "dev": "tsx src/index.ts",
+    "clean": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\"",
+    "build": "pnpm clean && tsc -p tsconfig.json",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "check": "pnpm typecheck && pnpm test",
+    "prepack": "pnpm build"
+  },
+  "dependencies": {
+    "commander": "^14.0.2",
+    "execa": "^9.6.1",
+    "ink": "^6.5.0",
+    "open": "^10.2.0",
+    "react": "^19.2.4",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@types/node": "^20.19.25",
+    "@types/react": "^19.2.7",
+    "tsx": "^4.22.4",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.8"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}