novence 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Novence
+
+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,98 @@
+# novence
+
+Deploy a static site to the edge in one command.
+
+```bash
+npx novence deploy ./dist
+```
+
+Uploads the directory, runs quality checks (Lighthouse, axe, links), publishes to
+`https://{suffix}.novence.ai/`, and prints the live URL.
+
+Part of [Novence](https://novence.ai) — static site hosting built for AI agents.
+
+## Install
+
+Run it directly with `npx`, or install it:
+
+```bash
+npm install -g novence
+```
+
+Requires Node 18+.
+
+## Deploy
+
+```bash
+novence deploy              # auto-detects dist, build, out, public, _site
+novence deploy ./site       # or point at a directory
+```
+
+First run asks for an email and a 6-digit code, then stores your API key in
+`~/.novence/credentials` (mode 0600). After that, deploys are one command.
+
+The live URL is the last line on stdout and progress goes to stderr, so it pipes:
+
+```bash
+URL=$(novence deploy ./dist)
+```
+
+### Flags
+
+| Flag | |
+| --- | --- |
+| `--name <name>` | Project name (default `site`) |
+| `--project <id>` | Redeploy an existing project instead of creating one |
+| `--email <email>` | Skip the email prompt on first run |
+| `--json` | Machine-readable output; implies `--no-input` |
+| `--no-input` | Never prompt — fail instead. For CI |
+| `--api <url>` | Control plane (default `https://api.novence.ai`) |
+
+## Other commands
+
+```bash
+novence login       # sign in, verify email, or recover a key with --recover
+novence projects    # list projects and their URLs
+novence whoami      # plan, verification, usage against quota
+```
+
+## For agents and CI
+
+`--json` gives a stable envelope and exits non-zero on failure:
+
+```json
+{
+  "ok": true,
+  "projectId": "…",
+  "deploymentId": "…",
+  "status": "live",
+  "url": "https://abcd1234.novence.ai/",
+  "files": 12,
+  "checks": { "passed": true }
+}
+```
+
+In CI, set `NOVENCE_API_KEY` and pass `--no-input`.
+
+Key lookup order: `NOVENCE_API_KEY`, then `./.novence-key`, then
+`~/.novence/credentials`. Never commit a key.
+
+## Checks
+
+Deploys run Lighthouse, axe, and link checks. On unverified accounts checks are
+skipped — `checks.skipped` is `true` and `checks.passed` is `null`, which is not
+a pass. Verify your email with `novence login` to enable them.
+
+## Roadmap
+
+Today the first deploy requires an email up front. Once anonymous deploys land in
+the API, `novence deploy` will publish first and let you claim the site
+afterwards — no signup before you see a URL.
+
+## Docs
+
+[Documentation](https://novence.ai/docs) · [Pricing](https://novence.ai/pricing) · [TypeScript SDK](https://www.npmjs.com/package/@novence/sdk) · [MCP server](https://novence.ai/mcp)
+
+## License
+
+MIT

package/dist/commands/deploy.d.ts

@@ -0,0 +1,2 @@
+import { type ParsedArgs } from "../lib/args.js";
+export declare function deployCommand(args: ParsedArgs): Promise<void>;

package/dist/commands/deploy.js

@@ -0,0 +1,111 @@
+import { existsSync, statSync } from "node:fs";
+import { resolve } from "node:path";
+import { Novence } from "@novence/sdk";
+import { ensureApiKey } from "../lib/auth.js";
+import { resolveApiBase } from "../lib/config.js";
+import { flagBool, flagString } from "../lib/args.js";
+import { fail, isJsonMode, json, result, step, warn } from "../lib/ui.js";
+const POLL_INTERVAL_MS = 2000;
+const POLL_TIMEOUT_MS = 5 * 60 * 1000;
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+/** Common build output directories, checked in order when no dir is given. */
+const CANDIDATE_DIRS = ["dist", "build", "out", "public", "_site"];
+function resolveSiteDir(explicit) {
+    if (explicit) {
+        const dir = resolve(explicit);
+        if (!existsSync(dir) || !statSync(dir).isDirectory())
+            fail(`Not a directory: ${dir}`);
+        return dir;
+    }
+    for (const candidate of CANDIDATE_DIRS) {
+        const dir = resolve(process.cwd(), candidate);
+        if (existsSync(dir) && statSync(dir).isDirectory())
+            return dir;
+    }
+    return fail(`No build output found. Looked for ${CANDIDATE_DIRS.join(", ")} in ${process.cwd()}.\n` +
+        "  Pass one explicitly:  novence deploy ./your-dir");
+}
+async function waitForLive(client, projectId) {
+    const startedAt = Date.now();
+    let lastStatus = "";
+    while (Date.now() - startedAt < POLL_TIMEOUT_MS) {
+        const { deployment } = await client.deployments.latest(projectId);
+        if (deployment.status !== lastStatus) {
+            step(`${deployment.status}…`);
+            lastStatus = deployment.status;
+        }
+        if (deployment.status === "live" || deployment.status === "failed")
+            return deployment;
+        await sleep(POLL_INTERVAL_MS);
+    }
+    return fail("Timed out after 5 minutes waiting for the deploy to go live.");
+}
+function reportChecks(deployment) {
+    const checks = deployment.checksResults;
+    if (!checks)
+        return;
+    if (checks.skipped) {
+        warn(`Checks skipped${checks.reason ? `: ${checks.reason}` : ""} (verify your email to enable)`);
+    }
+    else if (checks.passed === false) {
+        warn(`Quality checks failed${deployment.checksUrl ? ` — ${deployment.checksUrl}` : ""}`);
+    }
+    else if (checks.passed === true) {
+        step("Checks passed");
+    }
+}
+export async function deployCommand(args) {
+    const apiBase = resolveApiBase(flagString(args.flags, "api"));
+    const siteDir = resolveSiteDir(args.positionals[0]);
+    if (!existsSync(resolve(siteDir, "index.html"))) {
+        fail(`${siteDir} has no index.html — a static site needs one at its root.`);
+    }
+    const { apiKey } = await ensureApiKey({
+        apiBase,
+        email: flagString(args.flags, "email"),
+        interactive: !isJsonMode() && !flagBool(args.flags, "no-input"),
+    });
+    const client = new Novence({ apiKey, baseUrl: apiBase });
+    let projectId = flagString(args.flags, "project");
+    let siteUrl;
+    if (projectId) {
+        const { project } = await client.projects.get(projectId);
+        siteUrl = project.url;
+        step(`Reusing project ${project.name} (${project.suffix})`);
+    }
+    else {
+        const name = flagString(args.flags, "name") ?? "site";
+        const created = await client.projects.create({ name });
+        projectId = created.project.id;
+        siteUrl = created.url;
+        step(`Created project ${name} (${created.project.suffix})`);
+    }
+    step(`Uploading ${siteDir}…`);
+    const { uploaded } = await client.files.uploadDir(projectId, siteDir);
+    step(`Uploaded ${uploaded.length} file${uploaded.length === 1 ? "" : "s"}`);
+    await client.deployments.create(projectId);
+    const deployment = await waitForLive(client, projectId);
+    if (deployment.status === "failed") {
+        if (isJsonMode()) {
+            json({ ok: false, projectId, status: deployment.status, error: deployment.errorMessage });
+            process.exit(1);
+        }
+        fail(deployment.errorMessage ?? "Deploy failed.");
+    }
+    reportChecks(deployment);
+    const liveUrl = (deployment.liveUrl ?? siteUrl).replace(/\/?$/, "/");
+    if (isJsonMode()) {
+        json({
+            ok: true,
+            projectId,
+            deploymentId: deployment.id,
+            status: deployment.status,
+            url: liveUrl,
+            files: uploaded.length,
+            checks: deployment.checksResults ?? null,
+        });
+        return;
+    }
+    // Last line, alone, so it pipes cleanly.
+    result(liveUrl);
+}

package/dist/commands/login.d.ts

@@ -0,0 +1,2 @@
+import { type ParsedArgs } from "../lib/args.js";
+export declare function loginCommand(args: ParsedArgs): Promise<void>;

package/dist/commands/login.js

@@ -0,0 +1,32 @@
+import { reissueApiKey, resendVerification, verifyEmail } from "@novence/sdk";
+import { ensureApiKey } from "../lib/auth.js";
+import { credentialsPath, loadApiKey, resolveApiBase, saveApiKey } from "../lib/config.js";
+import { flagString } from "../lib/args.js";
+import { fail, prompt, result, step } from "../lib/ui.js";
+export async function loginCommand(args) {
+    const apiBase = resolveApiBase(flagString(args.flags, "api"));
+    const email = flagString(args.flags, "email");
+    // No key yet — the normal bootstrap path handles account creation + OTP.
+    if (!loadApiKey()) {
+        await ensureApiKey({ apiBase, email, interactive: true });
+        result(`Signed in. Key stored at ${credentialsPath()}`);
+        return;
+    }
+    // Key exists. Either verify this email, or recover a lost key via OTP.
+    const address = email ?? (await prompt("  Email: "));
+    if (!address.includes("@"))
+        fail(`Not a valid email: ${address}`);
+    step(`Sending a code to ${address}…`);
+    const sent = await resendVerification(address, apiBase);
+    const code = sent.verificationCode ?? (await prompt("  6-digit code from your email: "));
+    if (!code)
+        fail("No code entered.");
+    if (flagString(args.flags, "recover") !== undefined || args.flags.recover === true) {
+        const issued = await reissueApiKey(address, code, apiBase);
+        saveApiKey(issued.apiKey);
+        result(`Key reissued for account ${issued.accountId} → ${credentialsPath()}`);
+        return;
+    }
+    await verifyEmail(address, code, apiBase);
+    result(`${address} verified.`);
+}

package/dist/commands/projects.d.ts

@@ -0,0 +1,2 @@
+import { type ParsedArgs } from "../lib/args.js";
+export declare function projectsCommand(args: ParsedArgs): Promise<void>;

package/dist/commands/projects.js

@@ -0,0 +1,24 @@
+import { Novence } from "@novence/sdk";
+import { loadApiKey, resolveApiBase } from "../lib/config.js";
+import { flagString } from "../lib/args.js";
+import { fail, isJsonMode, json, result } from "../lib/ui.js";
+export async function projectsCommand(args) {
+    const apiBase = resolveApiBase(flagString(args.flags, "api"));
+    const apiKey = loadApiKey();
+    if (!apiKey)
+        fail("Not signed in. Run `novence login`.");
+    const client = new Novence({ apiKey, baseUrl: apiBase });
+    const { projects } = await client.projects.list();
+    if (isJsonMode()) {
+        json({ ok: true, projects });
+        return;
+    }
+    if (projects.length === 0) {
+        result("No projects yet. Run `novence deploy ./dist` to create one.");
+        return;
+    }
+    const width = Math.max(...projects.map((p) => p.name.length), 4);
+    for (const project of projects) {
+        result(`${project.name.padEnd(width)}  ${project.suffix}  ${project.url}`);
+    }
+}

package/dist/commands/whoami.d.ts

@@ -0,0 +1,2 @@
+import { type ParsedArgs } from "../lib/args.js";
+export declare function whoamiCommand(args: ParsedArgs): Promise<void>;

package/dist/commands/whoami.js

@@ -0,0 +1,37 @@
+import { Novence } from "@novence/sdk";
+import { keySource, loadApiKey, resolveApiBase } from "../lib/config.js";
+import { flagString } from "../lib/args.js";
+import { fail, isJsonMode, json, result } from "../lib/ui.js";
+export async function whoamiCommand(args) {
+    const apiBase = resolveApiBase(flagString(args.flags, "api"));
+    const apiKey = loadApiKey();
+    if (!apiKey)
+        fail("Not signed in. Run `novence login`.");
+    const client = new Novence({ apiKey, baseUrl: apiBase });
+    const quotas = await client.billing.quotas();
+    // Project count is not part of the usage payload — count them directly.
+    const { projects } = await client.projects.list();
+    if (isJsonMode()) {
+        json({ ok: true, ...quotas, projectCount: projects.length, apiBase });
+        return;
+    }
+    result(`plan            ${quotas.plan}`);
+    result(`email verified  ${quotas.emailVerified ? "yes" : "no"}`);
+    result(`api             ${apiBase}`);
+    result(`key             ${keySource()}`);
+    result(`projects        ${projects.length} / ${quotas.quotas.projects}`);
+    result(`deploys (mo)    ${quotas.usage.deploys_count ?? 0} / ${quotas.quotas.deploysPerMonth}`);
+    result(`storage         ${formatBytes(quotas.usage.storage_bytes ?? 0)} / ${quotas.quotas.storageGb} GB`);
+}
+function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    const units = ["KB", "MB", "GB"];
+    let value = bytes / 1024;
+    let unit = 0;
+    while (value >= 1024 && unit < units.length - 1) {
+        value /= 1024;
+        unit += 1;
+    }
+    return `${value < 10 ? value.toFixed(1) : Math.round(value)} ${units[unit]}`;
+}

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { flagBool, parseArgs } from "./lib/args.js";
+import { fail, isJsonMode, result, setJsonMode } from "./lib/ui.js";
+import { deployCommand } from "./commands/deploy.js";
+import { loginCommand } from "./commands/login.js";
+import { projectsCommand } from "./commands/projects.js";
+import { whoamiCommand } from "./commands/whoami.js";
+const HELP = `
+  novence — deploy a static site to the edge
+
+  Usage
+    novence deploy [dir]        Upload a directory and publish it live
+    novence login               Sign in, verify email, or recover a key
+    novence projects            List your projects and their URLs
+    novence whoami              Show plan, verification, and usage
+
+  Deploy
+    novence deploy              Auto-detects dist, build, out, public, _site
+    novence deploy ./site       Deploy a specific directory
+    --name <name>               Project name (default: "site")
+    --project <id>              Redeploy an existing project
+    --email <email>             Skip the email prompt on first run
+
+  Global
+    --json                      Machine-readable output (implies --no-input)
+    --no-input                  Never prompt; fail instead
+    --api <url>                 Control plane (default https://api.novence.ai)
+    -h, --help                  Show this help
+    -v, --version               Show the version
+
+  The live URL is the last line on stdout, so it pipes:
+    URL=$(novence deploy ./dist)
+
+  Auth
+    Reads NOVENCE_API_KEY, then ./.novence-key, then ~/.novence/credentials.
+
+  Docs  https://novence.ai/docs
+`;
+function version() {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const pkg = JSON.parse(readFileSync(join(here, "..", "package.json"), "utf8"));
+    return pkg.version;
+}
+async function main() {
+    const args = parseArgs(process.argv.slice(2));
+    if (flagBool(args.flags, "json"))
+        setJsonMode(true);
+    if (flagBool(args.flags, "version"))
+        return result(version());
+    if (!args.command || flagBool(args.flags, "help")) {
+        if (isJsonMode())
+            return result(version());
+        process.stdout.write(HELP);
+        return;
+    }
+    switch (args.command) {
+        case "deploy":
+            return deployCommand(args);
+        case "login":
+            return loginCommand(args);
+        case "projects":
+        case "ls":
+            return projectsCommand(args);
+        case "whoami":
+            return whoamiCommand(args);
+        default:
+            fail(`Unknown command: ${args.command}\n  Run \`novence --help\` for usage.`);
+    }
+}
+main().catch((err) => {
+    fail(err instanceof Error ? err.message : String(err));
+});

package/dist/lib/args.d.ts

@@ -0,0 +1,9 @@
+export interface ParsedArgs {
+    command: string | null;
+    positionals: string[];
+    flags: Record<string, string | boolean>;
+}
+/** Supports --flag, --flag=value, --flag value, and -h/-v shorthands. */
+export declare function parseArgs(argv: string[]): ParsedArgs;
+export declare function flagString(flags: ParsedArgs["flags"], name: string): string | undefined;
+export declare function flagBool(flags: ParsedArgs["flags"], name: string): boolean;

package/dist/lib/args.js

@@ -0,0 +1,42 @@
+/** Supports --flag, --flag=value, --flag value, and -h/-v shorthands. */
+export function parseArgs(argv) {
+    const flags = {};
+    const positionals = [];
+    for (let i = 0; i < argv.length; i += 1) {
+        const token = argv[i];
+        if (token === "-h") {
+            flags.help = true;
+        }
+        else if (token === "-v") {
+            flags.version = true;
+        }
+        else if (token.startsWith("--")) {
+            const body = token.slice(2);
+            const eq = body.indexOf("=");
+            if (eq !== -1) {
+                flags[body.slice(0, eq)] = body.slice(eq + 1);
+            }
+            else {
+                const next = argv[i + 1];
+                if (next && !next.startsWith("-")) {
+                    flags[body] = next;
+                    i += 1;
+                }
+                else {
+                    flags[body] = true;
+                }
+            }
+        }
+        else {
+            positionals.push(token);
+        }
+    }
+    return { command: positionals[0] ?? null, positionals: positionals.slice(1), flags };
+}
+export function flagString(flags, name) {
+    const value = flags[name];
+    return typeof value === "string" ? value : undefined;
+}
+export function flagBool(flags, name) {
+    return flags[name] === true || flags[name] === "true";
+}

package/dist/lib/auth.d.ts

@@ -0,0 +1,17 @@
+export interface Credentials {
+    apiKey: string;
+    /** True when this run created the account, so callers can tailor next steps. */
+    fresh: boolean;
+}
+/**
+ * Returns a usable API key, bootstrapping interactively if none is stored.
+ *
+ * The API currently requires an email at bootstrap. Once anonymous deploys land
+ * (`POST /v1/demo`), deploy should publish first and claim afterwards — see the
+ * deploy-first note in the README.
+ */
+export declare function ensureApiKey(opts: {
+    apiBase: string;
+    email?: string;
+    interactive: boolean;
+}): Promise<Credentials>;

package/dist/lib/auth.js

@@ -0,0 +1,54 @@
+import { bootstrapAccount, verifyEmail } from "@novence/sdk";
+import { loadApiKey, saveApiKey } from "./config.js";
+import { fail, prompt, step, warn } from "./ui.js";
+/**
+ * Returns a usable API key, bootstrapping interactively if none is stored.
+ *
+ * The API currently requires an email at bootstrap. Once anonymous deploys land
+ * (`POST /v1/demo`), deploy should publish first and claim afterwards — see the
+ * deploy-first note in the README.
+ */
+export async function ensureApiKey(opts) {
+    const existing = loadApiKey();
+    if (existing)
+        return { apiKey: existing, fresh: false };
+    if (!opts.interactive) {
+        fail("No API key found. Set NOVENCE_API_KEY, or run `novence login` first.\n" +
+            "  Non-interactive runs cannot complete the email OTP step.");
+    }
+    const email = opts.email ?? (await prompt("  Email (for your account + site URL): "));
+    if (!email.includes("@"))
+        fail(`Not a valid email: ${email}`);
+    step(`Creating your account (${email})…`);
+    let boot;
+    try {
+        boot = await bootstrapAccount(email, opts.apiBase);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (/exists|already|409/i.test(message)) {
+            fail(`${email} already has an account. Recover the key with an OTP:\n` +
+                "  novence login --email " + email);
+        }
+        throw err;
+    }
+    const path = saveApiKey(boot.apiKey);
+    step(`Account ${boot.accountId} · plan ${boot.plan}`);
+    step(`Key saved to ${path}`);
+    if (boot.verificationCode) {
+        // Local/dev API returns the OTP inline.
+        await verifyEmail(email, boot.verificationCode, opts.apiBase);
+        step("Email verified");
+    }
+    else if (boot.emailVerificationRequired) {
+        const code = await prompt("  6-digit code from your email (Enter to skip): ");
+        if (code) {
+            await verifyEmail(email, code, opts.apiBase);
+            step("Email verified");
+        }
+        else {
+            warn("Unverified: 1 project, 3 deploys/mo, checks skipped. Run `novence login` to verify.");
+        }
+    }
+    return { apiKey: boot.apiKey, fresh: true };
+}

package/dist/lib/config.d.ts

@@ -0,0 +1,13 @@
+export declare const DEFAULT_API = "https://api.novence.ai";
+/** Explicit flag wins, then env, then the public control plane. */
+export declare function resolveApiBase(flag?: string): string;
+/**
+ * Key lookup order: NOVENCE_API_KEY, then a project-local .novence-key (what
+ * scripts/launch-site.ts writes), then ~/.novence/credentials.
+ */
+export declare function loadApiKey(): string | null;
+/** Written 0600 — this is a live credential. */
+export declare function saveApiKey(apiKey: string): string;
+export declare function credentialsPath(): string;
+/** Where loadApiKey() found the key, for display. */
+export declare function keySource(): string;

package/dist/lib/config.js

@@ -0,0 +1,54 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+const CONFIG_DIR = join(homedir(), ".novence");
+const CREDENTIALS_FILE = join(CONFIG_DIR, "credentials");
+export const DEFAULT_API = "https://api.novence.ai";
+/** Explicit flag wins, then env, then the public control plane. */
+export function resolveApiBase(flag) {
+    const raw = flag ?? process.env.NOVENCE_BASE_URL ?? process.env.API_BASE_URL ?? DEFAULT_API;
+    return raw.replace(/\/$/, "");
+}
+/**
+ * Key lookup order: NOVENCE_API_KEY, then a project-local .novence-key (what
+ * scripts/launch-site.ts writes), then ~/.novence/credentials.
+ */
+export function loadApiKey() {
+    const fromEnv = process.env.NOVENCE_API_KEY?.trim();
+    if (fromEnv)
+        return fromEnv;
+    const local = join(process.cwd(), ".novence-key");
+    if (existsSync(local)) {
+        const key = readFileSync(local, "utf8").trim();
+        if (key)
+            return key;
+    }
+    if (existsSync(CREDENTIALS_FILE)) {
+        const key = readFileSync(CREDENTIALS_FILE, "utf8").trim();
+        if (key)
+            return key;
+    }
+    return null;
+}
+/** Written 0600 — this is a live credential. */
+export function saveApiKey(apiKey) {
+    mkdirSync(dirname(CREDENTIALS_FILE), { recursive: true, mode: 0o700 });
+    writeFileSync(CREDENTIALS_FILE, apiKey.trim() + "\n", { mode: 0o600 });
+    chmodSync(CREDENTIALS_FILE, 0o600);
+    return CREDENTIALS_FILE;
+}
+export function credentialsPath() {
+    return CREDENTIALS_FILE;
+}
+/** Where loadApiKey() found the key, for display. */
+export function keySource() {
+    if (process.env.NOVENCE_API_KEY?.trim())
+        return "NOVENCE_API_KEY";
+    const local = join(process.cwd(), ".novence-key");
+    if (existsSync(local) && readFileSync(local, "utf8").trim())
+        return local;
+    if (existsSync(CREDENTIALS_FILE) && readFileSync(CREDENTIALS_FILE, "utf8").trim()) {
+        return CREDENTIALS_FILE;
+    }
+    return "(none)";
+}

package/dist/lib/ui.d.ts

@@ -0,0 +1,10 @@
+export declare function setJsonMode(on: boolean): void;
+export declare function isJsonMode(): boolean;
+/** Progress goes to stderr so `novence deploy … > url.txt` stays clean. */
+export declare function step(message: string): void;
+export declare function warn(message: string): void;
+/** The one line callers pipe. Always stdout. */
+export declare function result(value: string): void;
+export declare function json(value: unknown): void;
+export declare function fail(message: string): never;
+export declare function prompt(question: string): Promise<string>;

package/dist/lib/ui.js

@@ -0,0 +1,48 @@
+import { createInterface } from "node:readline/promises";
+import { stdin, stdout } from "node:process";
+let jsonMode = false;
+export function setJsonMode(on) {
+    jsonMode = on;
+}
+export function isJsonMode() {
+    return jsonMode;
+}
+/** Progress goes to stderr so `novence deploy … > url.txt` stays clean. */
+export function step(message) {
+    if (!jsonMode)
+        process.stderr.write(`  ${message}\n`);
+}
+export function warn(message) {
+    process.stderr.write(`  ! ${message}\n`);
+}
+/** The one line callers pipe. Always stdout. */
+export function result(value) {
+    stdout.write(value + "\n");
+}
+export function json(value) {
+    stdout.write(JSON.stringify(value, null, 2) + "\n");
+}
+export function fail(message) {
+    if (jsonMode) {
+        stdout.write(JSON.stringify({ ok: false, error: message }, null, 2) + "\n");
+    }
+    else {
+        process.stderr.write(`\n  Error: ${message}\n`);
+    }
+    process.exit(1);
+}
+export async function prompt(question) {
+    if (!stdin.isTTY) {
+        fail(`Cannot prompt for "${question.trim()}" — stdin is not a TTY. Pass the value as a flag.`);
+    }
+    const rl = createInterface({ input: stdin, output: stderr() });
+    try {
+        return (await rl.question(question)).trim();
+    }
+    finally {
+        rl.close();
+    }
+}
+function stderr() {
+    return process.stderr;
+}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "novence",
+  "version": "0.0.1",
+  "description": "CLI for Novence — deploy a static site to the edge in one command.",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "novence": "./dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "homepage": "https://novence.ai/docs",
+  "bugs": {
+    "url": "https://novence.ai/support"
+  },
+  "keywords": [
+    "novence",
+    "static-site-hosting",
+    "deploy",
+    "cli",
+    "hosting",
+    "edge",
+    "static-site",
+    "ai-agents"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "prepublishOnly": "pnpm run build"
+  },
+  "dependencies": {
+    "@novence/sdk": "^0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.2",
+    "typescript": "^5.7.2"
+  }
+}