@incajs/cli 0.0.0 → 0.0.2

package/dist/cli.d.mts

@@ -0,0 +1,2 @@
+/** Parses argv and runs the named subcommand: `dev`, `build`, or `package`. */
+export declare function run(argv?: readonly string[]): Promise<void>;

package/dist/cli.js

@@ -0,0 +1,503 @@
+import { i as e, n as t, o as n, r, t as i } from "./chunks/defaults-EWjAFeZ3.js";
+import { existsSync as a } from "node:fs";
+import { chmod as o, cp as s, mkdir as c, readFile as l, readdir as u, rm as d, writeFile as f } from "node:fs/promises";
+import p from "node:path";
+import { build as m } from "vite";
+import h from "@vitejs/plugin-vue";
+import { createRequire as g } from "node:module";
+import { spawn as _ } from "node:child_process";
+import { once as v } from "node:events";
+import y from "node:readline";
+import { setTimeout as b } from "node:timers/promises";
+//#region src/config/loader.mts
+async function x(e) {
+	let { config: t } = await n({
+		cwd: e,
+		name: "inca",
+		packageJson: "inca",
+		rcFile: !1,
+		globalRc: !1,
+		giget: !1,
+		extend: !1
+	});
+	return {
+		entry: t.entry ? p.resolve(e, t.entry) : void 0,
+		outDir: p.resolve(e, t.outDir ?? i.outDir)
+	};
+}
+async function S(e) {
+	let o = p.join(e, "package.json"), s;
+	try {
+		s = await l(o, "utf8");
+	} catch {
+		throw Error(`no package.json found at ${o}`);
+	}
+	let c = JSON.parse(s), { config: u, layers: d } = await n({
+		cwd: e,
+		name: "inca",
+		packageJson: "inca",
+		rcFile: !1,
+		globalRc: !1,
+		giget: !1,
+		extend: !1
+	}), f = d?.find((e) => e.configFile === "package.json"), m = Object.keys(f?.config ?? {}).length > 0, h = u.productName ?? r(c.name);
+	if (!h) throw Error(`${o} needs a "name", or "productName" in inca.config.ts`);
+	let g = u.version ?? c.version ?? i.version, _ = u.identifier ?? t(h), v;
+	if (u.icon && (v = p.resolve(e, u.icon), !a(v))) throw Error(`"icon" points to ${v}, which doesn't exist`);
+	let y = u.entry ? p.resolve(e, u.entry) : void 0, b = p.resolve(e, u.outDir ?? i.outDir);
+	return {
+		productName: h,
+		identifier: _,
+		identifierIsDefault: u.identifier === void 0,
+		version: g,
+		icon: v,
+		entry: y,
+		outDir: b,
+		usedPackageJsonKey: m
+	};
+}
+//#endregion
+//#region src/adapter/vite/captureOutput.mts
+function C(e) {
+	return {
+		name: "inca:capture-output",
+		writeBundle(t, n) {
+			let r = Object.keys(n), i = Object.values(n).find((e) => e.type === "chunk" && e.isEntry);
+			if (!i) throw Error("inca: build produced no entry chunk");
+			e({
+				entryFile: i.fileName,
+				files: r
+			});
+		}
+	};
+}
+//#endregion
+//#region src/adapter/vite/config.mts
+var w = "bundle.js";
+function T({ entry: e, outDir: t, mode: n, watch: r, onOutput: i }) {
+	return {
+		configFile: !1,
+		root: p.dirname(e),
+		mode: n,
+		clearScreen: !1,
+		logLevel: "silent",
+		define: { "process.env.NODE_ENV": JSON.stringify(n) },
+		plugins: [h({ template: { compilerOptions: { runtimeModuleName: "@vue/runtime-core" } } }), C(i)],
+		build: {
+			lib: {
+				entry: e,
+				formats: ["es"],
+				fileName: () => w
+			},
+			outDir: t,
+			emptyOutDir: n === "production",
+			minify: n === "production",
+			watch: r ? {} : void 0,
+			rolldownOptions: { output: {
+				chunkFileNames: "chunks/[name]-[hash].js",
+				assetFileNames: "assets/[name]-[hash][extname]"
+			} }
+		}
+	};
+}
+//#endregion
+//#region src/adapter/vite/build.mts
+async function E({ entry: e, outDir: t }) {
+	let n;
+	if (await m(T({
+		entry: e,
+		outDir: t,
+		mode: "production",
+		watch: !1,
+		onOutput: (e) => {
+			n = {
+				outDir: t,
+				entryFile: p.join(t, e.entryFile),
+				files: e.files
+			};
+		}
+	})), !n) throw Error("inca: build produced no output");
+	return n;
+}
+//#endregion
+//#region src/adapter/vite/watch.mts
+async function D({ onBuild: e, onError: t, ...n }) {
+	let { outDir: r } = n, i = await m(T({
+		...n,
+		watch: !0,
+		onOutput: (t) => {
+			e({
+				outDir: r,
+				entryFile: p.join(r, t.entryFile),
+				files: t.files
+			});
+		}
+	}));
+	return i.on("event", (e) => {
+		e.code === "ERROR" && t({
+			message: e.error.message,
+			stack: e.error.stack ?? null
+		});
+	}), { close: () => i.close() };
+}
+//#endregion
+//#region src/defaultBundler.mts
+var O = {
+	watch: D,
+	build: E
+};
+//#endregion
+//#region src/entry.mts
+async function k(e) {
+	let t = p.join(e, "src/main.mts");
+	if (a(t)) return t;
+	let n = p.join(e, "src/App.vue");
+	if (a(n)) return A(n, e);
+	throw Error(`no app entry found — expected ${t} or ${n}`);
+}
+async function A(e, t) {
+	let n = p.join(t, "node_modules/.inca");
+	await c(n, { recursive: !0 });
+	let r = p.join(n, "entry.mts"), i = JSON.stringify(e.split(p.sep).join("/"));
+	return await f(r, `import { createIncaApp } from "incajs/vue";\nimport App from ${i};\ncreateIncaApp(App).mount();\n`), r;
+}
+//#endregion
+//#region src/build.mts
+async function j(e = {}) {
+	let t = e.cwd ?? process.cwd(), n = e.config ?? await x(t), r = n.outDir, i = e.bundler ?? O, a = e.entry ?? n.entry ?? await k(t);
+	return i.build({
+		entry: a,
+		outDir: r
+	});
+}
+//#endregion
+//#region src/dev-client/hostBin.mts
+var M = "INCA_HOST_BIN";
+function N() {
+	let e = process.platform === "darwin" || process.platform === "linux" ? process.platform : void 0, t = process.arch === "arm64" || process.arch === "x64" ? process.arch : void 0;
+	return e && t ? `@incajs/host-${e}-${t}` : void 0;
+}
+function P() {
+	let e = N();
+	if (e) try {
+		return g(import.meta.url).resolve(`${e}/bin/inca-host`);
+	} catch {
+		return;
+	}
+}
+function F() {
+	let e = process.env[M];
+	if (e) return e;
+	let t = P();
+	if (t) return t;
+	let n = N(), r = n ? `no ${n} package is installed for it` : `this platform (${process.platform}/${process.arch}) has no published package`;
+	throw Error(`no inca-host binary found — ${r}, and ${M} isn't set to one`);
+}
+//#endregion
+//#region src/dev-client/hostError.mts
+var I = class extends Error {
+	code;
+	hostStack;
+	constructor(e, t, n = null) {
+		super(e), this.code = t, this.hostStack = n, this.name = "HostError";
+	}
+};
+function L(e) {
+	return typeof e == "object" && !!e && e.jsonrpc === "2.0";
+}
+//#endregion
+//#region src/dev-client/hostClient.mts
+var R = (e) => {
+	process.stderr.write(e.endsWith("\n") ? e : `${e}\n`);
+}, z = class {
+	#e;
+	#t;
+	#n = 1;
+	#r = /* @__PURE__ */ new Map();
+	constructor(e) {
+		this.#e = e;
+	}
+	async start() {
+		let e = this.#e.hostBin ?? F(), t = _(e, ["--dev", this.#e.entryFile], { stdio: [
+			"pipe",
+			"pipe",
+			"pipe"
+		] });
+		this.#t = t;
+		let n = this.#e.onStderr ?? R;
+		t.stderr.setEncoding("utf8"), t.stderr.on("data", (e) => n(e)), y.createInterface({ input: t.stdout }).on("line", (e) => {
+			this.#i(e, n);
+		}), t.on("exit", (e, t) => {
+			let n = /* @__PURE__ */ Error(`inca-host exited (code=${String(e)}, signal=${String(t)}) before answering`);
+			for (let { reject: e } of this.#r.values()) e(n);
+			this.#r.clear();
+		}), await v(t, "spawn");
+	}
+	#i(e, t) {
+		let n;
+		try {
+			n = JSON.parse(e);
+		} catch {
+			t(`[stray stdout] ${e}`);
+			return;
+		}
+		if (!L(n)) {
+			t(`[stray stdout] ${e}`);
+			return;
+		}
+		if ("method" in n) {
+			this.#a(n.method, n.params, t);
+			return;
+		}
+		let r = this.#r.get(n.id);
+		r && (this.#r.delete(n.id), "error" in n ? r.reject(new I(n.error.message, n.error.code, n.error.data?.stack ?? null)) : r.resolve(n.result));
+	}
+	#a(e, t, n) {
+		switch (e) {
+			case "ready": {
+				let { protocol: e } = t;
+				if (e !== 0) {
+					n(`inca-host speaks protocol ${String(e)}, this package was built for 0 — stopping it rather than carrying on`), this.#t && this.#o(this.#t);
+					return;
+				}
+				this.#e.onReady?.();
+				return;
+			}
+			case "appError":
+				this.#e.onAppError?.(t);
+				return;
+			default: {
+				let r = this.#e.integrations?.[e];
+				r ? r(t) : n(`[unhandled notification] ${e}`);
+			}
+		}
+	}
+	async #o(e) {
+		let t = v(e, "exit");
+		e.kill(), await t;
+	}
+	async call(e, t) {
+		let n = this.#t;
+		if (!n) throw Error("HostClient.start() has not been called");
+		let r = this.#n++, i = JSON.stringify({
+			jsonrpc: "2.0",
+			id: r,
+			method: e,
+			params: t
+		});
+		return new Promise((e, t) => {
+			this.#r.set(r, {
+				resolve: e,
+				reject: t
+			}), n.stdin.write(`${i}\n`);
+		});
+	}
+	async stop(e = 2e3) {
+		let t = this.#t;
+		if (!t || t.exitCode !== null || t.signalCode !== null) return;
+		let n = v(t, "exit");
+		this.call("shutdown").catch(() => {}), await Promise.race([n.then(() => "exited"), b(e).then(() => "timeout")]) === "timeout" && (t.kill(), await n);
+	}
+};
+//#endregion
+//#region src/fault.mts
+function B(e) {
+	return e instanceof I ? {
+		message: e.message,
+		stack: e.hostStack
+	} : e instanceof Error ? {
+		message: e.message,
+		stack: e.stack ?? null
+	} : {
+		message: String(e),
+		stack: null
+	};
+}
+function V(e, t, n) {
+	e.write(`[inca] ${t}: ${n.message}\n`), n.stack && e.write(`${n.stack}\n`);
+}
+//#endregion
+//#region src/dev.mts
+async function H(e, t) {
+	let n = new Set(t), r;
+	try {
+		r = await u(e, {
+			recursive: !0,
+			withFileTypes: !0
+		});
+	} catch {
+		return;
+	}
+	await Promise.all(r.filter((e) => e.isFile()).map((t) => p.relative(e, p.join(t.parentPath, t.name))).filter((e) => !n.has(e)).map((t) => d(p.join(e, t), { force: !0 })));
+}
+async function U(e) {
+	let t = e.cwd ?? process.cwd(), n = await x(t), r = n.outDir, i = e.bundler ?? O, a = e.stdout ?? process.stdout, o = e.stderr ?? process.stderr, s = e.entry ?? n.entry ?? await k(t), c, l = !1, u = !1, d = Promise.resolve();
+	async function f() {
+		try {
+			await c?.call("reload");
+		} catch (e) {
+			V(o, "reload failed", B(e));
+		}
+	}
+	async function p(t) {
+		if (await H(t.outDir, t.files), !c) {
+			let n = new z({
+				entryFile: t.entryFile,
+				hostBin: e.hostBin,
+				onStderr: (e) => o.write(e),
+				onReady: () => {
+					l = !0, a.write("[inca] ready\n"), u && (u = !1, f());
+				},
+				onAppError: (e) => V(o, "app error", e)
+			});
+			try {
+				await n.start();
+			} catch (e) {
+				V(o, "failed to start inca-host", B(e));
+				return;
+			}
+			c = n;
+			return;
+		}
+		if (!l) {
+			u = !0;
+			return;
+		}
+		await f();
+	}
+	let m = await i.watch({
+		entry: s,
+		outDir: r,
+		mode: "development",
+		onBuild: (e) => {
+			d = d.then(() => p(e));
+		},
+		onError: (e) => {
+			V(o, "build failed", e);
+		}
+	});
+	await new Promise((t) => {
+		if (e.signal.aborted) {
+			t();
+			return;
+		}
+		e.signal.addEventListener("abort", () => t(), { once: !0 });
+	}), await d, await c?.stop(), await m.close();
+}
+//#endregion
+//#region src/plist.mts
+function W(e) {
+	return e.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+function G(e) {
+	return typeof e == "boolean" ? e ? "<true/>" : "<false/>" : `<string>${W(e)}</string>`;
+}
+function K(e) {
+	return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+${Object.entries(e).map(([e, t]) => `\t<key>${W(e)}</key>\n\t${G(t)}`).join("\n")}\n</dict>
+</plist>
+`;
+}
+//#endregion
+//#region src/package.mts
+function q() {
+	if (process.platform === "darwin") return "macos";
+	if (process.platform === "linux") return "linux";
+	throw Error(`inca package doesn't support ${process.platform} yet`);
+}
+async function J(e, t) {
+	await Promise.all(e.files.map(async (n) => {
+		let r = p.join(t, n);
+		await c(p.dirname(r), { recursive: !0 }), await s(p.join(e.outDir, n), r);
+	}));
+}
+async function Y({ metadata: e, output: t, hostBin: n }) {
+	let r = p.join(t.outDir, `${e.productName}.app`);
+	await d(r, {
+		recursive: !0,
+		force: !0
+	});
+	let i = p.join(r, "Contents"), a = p.join(i, "MacOS"), l = p.join(i, "Resources");
+	await c(a, { recursive: !0 }), await c(l, { recursive: !0 });
+	let u = p.join(a, e.productName);
+	await s(n, u), await o(u, 493), await J(t, l);
+	let m = {
+		CFBundleName: e.productName,
+		CFBundleDisplayName: e.productName,
+		CFBundleExecutable: e.productName,
+		CFBundleIdentifier: e.identifier,
+		CFBundleVersion: e.version,
+		CFBundleShortVersionString: e.version,
+		CFBundlePackageType: "APPL",
+		CFBundleInfoDictionaryVersion: "6.0",
+		NSHighResolutionCapable: !0
+	};
+	if (e.icon) {
+		let t = p.basename(e.icon);
+		await s(e.icon, p.join(l, t)), m.CFBundleIconFile = t;
+	}
+	return await f(p.join(i, "Info.plist"), K(m)), await f(p.join(i, "PkgInfo"), "APPL????"), r;
+}
+async function X({ metadata: t, output: n, hostBin: r }) {
+	let i = e(t.productName), a = p.join(n.outDir, i);
+	await d(a, {
+		recursive: !0,
+		force: !0
+	}), await c(a, { recursive: !0 });
+	let l = p.join(a, i);
+	return await s(r, l), await o(l, 493), await J(n, a), a;
+}
+async function Z(e = {}) {
+	let t = e.cwd ?? process.cwd(), n = e.stdout ?? process.stdout, r = e.target ?? q(), i = await S(t);
+	i.usedPackageJsonKey && n.write("[inca] the \"inca\" key in package.json is deprecated — move these settings to inca.config.ts\n"), i.identifierIsDefault && n.write(`[inca] no "identifier" set in inca.config.ts — using generated identifier ${i.identifier}\n`);
+	let o = await j({
+		cwd: t,
+		entry: e.entry,
+		config: i,
+		bundler: e.bundler
+	}), s = e.hostBin ?? F();
+	if (!a(s)) throw Error(`no host binary at ${s} — check that it was built and is executable`);
+	let c = {
+		metadata: i,
+		output: o,
+		hostBin: s
+	};
+	return { appPath: r === "macos" ? await Y(c) : await X(c) };
+}
+//#endregion
+//#region src/cli.mts
+var Q = "Usage: inca <dev|build|package>";
+async function $(e = process.argv) {
+	let t = e[2];
+	if (t === "build") {
+		try {
+			let e = await j();
+			process.stdout.write(`[inca] built ${e.entryFile}\n`);
+		} catch (e) {
+			V(process.stderr, "build failed", B(e)), process.exitCode = 1;
+		}
+		return;
+	}
+	if (t === "package") {
+		try {
+			let { appPath: e } = await Z();
+			process.stdout.write(`[inca] packaged ${e}\n`);
+		} catch (e) {
+			V(process.stderr, "package failed", B(e)), process.exitCode = 1;
+		}
+		return;
+	}
+	if (t !== "dev") {
+		process.stderr.write(`${Q}\n`), process.exitCode = 1;
+		return;
+	}
+	let n = new AbortController(), r = () => {
+		process.stderr.write("[inca] shutting down\n"), n.abort();
+	};
+	process.on("SIGINT", r), process.on("SIGTERM", r), await U({ signal: n.signal });
+}
+//#endregion
+export { $ as run };

package/dist/config/defaults.d.mts

@@ -0,0 +1,44 @@
+import { IncaConfig } from './types.mts';
+/**
+ * The `IncaConfig` fields whose default is a fixed value rather than one
+ * derived from `package.json` or the filesystem — importable alongside
+ * `defineConfig` for an app that wants to inherit or reference them.
+ *
+ * @example
+ * ```ts
+ * import { defaultConfig, defineConfig } from "@incajs/cli/config";
+ *
+ * export default defineConfig({
+ *   ...defaultConfig,
+ *   outDir: "build",
+ * });
+ * ```
+ */
+export declare const defaultConfig: Required<Pick<IncaConfig, "outDir" | "version">>;
+/**
+ * Strips an npm scope off a package name.
+ *
+ * @param name - a `package.json` `"name"`, e.g. `@incajs/cli` or `incajs`
+ * @returns the name with its scope removed, e.g. `cli`; an unscoped name
+ * passes through unchanged
+ */
+export declare function unscopedName(name: string): string;
+/**
+ * Turns a display name into a filesystem/URL-safe slug.
+ *
+ * @param name - e.g. a `productName`
+ * @returns `name` lowercased, with runs of non-`[a-z0-9]` collapsed to a
+ * single `-` and trimmed from both ends
+ */
+export declare function slugify(name: string): string;
+/**
+ * @param pkgName - `package.json`'s own `"name"`, if it has one
+ * @returns the `productName` a plain `package.json` implies — its name with
+ * any scope stripped — or `undefined` if it has none
+ */
+export declare function defaultProductName(pkgName: string | undefined): string | undefined;
+/**
+ * @param productName - the app's resolved display name
+ * @returns a generated `identifier`, e.g. `org.inca.click-counter`
+ */
+export declare function defaultIdentifier(productName: string): string;

package/dist/config/index.d.mts

@@ -0,0 +1,18 @@
+import { IncaConfig } from './types.mts';
+export { defaultConfig } from './defaults.mts';
+export type { IncaConfig } from './types.mts';
+/**
+ * Type-completion helper for `inca.config.ts` — an identity function at
+ * runtime, the same way `defineConfig` from `vite` or `vitest/config` works.
+ *
+ * @example
+ * ```ts
+ * import { defineConfig } from "@incajs/cli/config";
+ *
+ * export default defineConfig({
+ *   productName: "Click Counter",
+ *   identifier: "com.example.click-counter",
+ * });
+ * ```
+ */
+export declare const defineConfig: import('c12').DefineConfig<IncaConfig, import('c12').ConfigLayerMeta>;

package/dist/config/loader.d.mts

@@ -0,0 +1,37 @@
+/** `entry`/`outDir` only — what `build()`/`dev()` need, with no `package.json` requirement. */
+export interface ResolvedBuildConfig {
+    /** Absolute path, if `inca.config.ts` set one. */
+    entry?: string;
+    /** Absolute path. */
+    outDir: string;
+}
+/** An app's full config, as `inca package` needs it. */
+export interface ResolvedAppConfig extends ResolvedBuildConfig {
+    productName: string;
+    identifier: string;
+    /** True when `identifier` was generated rather than set explicitly. */
+    identifierIsDefault: boolean;
+    version: string;
+    /** Absolute path, if the app declared one. */
+    icon?: string;
+    /** package.json's `"inca"` key is deprecated; callers warn when this is true. */
+    usedPackageJsonKey: boolean;
+}
+/**
+ * Loads just `entry`/`outDir` from `inca.config.ts`, with derived defaults.
+ * Never touches `package.json`.
+ *
+ * @param cwd - the app's root directory
+ * @returns `entry`/`outDir`, resolved to absolute paths
+ */
+export declare function resolveBuildConfig(cwd: string): Promise<ResolvedBuildConfig>;
+/**
+ * Loads an app's full config for `inca package`: `inca.config.ts` over
+ * `package.json`'s `"inca"` key over derived defaults.
+ *
+ * @param cwd - the app's root directory
+ * @returns the resolved config
+ * @throws if `package.json` is missing, has neither a `name` nor a
+ * `productName`, or an `icon` doesn't resolve to a real file
+ */
+export declare function resolveAppConfig(cwd: string): Promise<ResolvedAppConfig>;

package/dist/config/types.d.mts

@@ -0,0 +1,35 @@
+/**
+ * An app's own `inca.config.ts` (or `.js`/`.json`), loaded by `@incajs/cli`.
+ * `package.json`'s `"inca"` key still works as a fallback, but is
+ * deprecated — this file wins where both are present.
+ */
+export interface IncaConfig {
+    /** Path to an icon file, resolved relative to this config file's own directory. */
+    icon?: string;
+    /**
+     * A reverse-DNS-style unique id — e.g. macOS's `CFBundleIdentifier`.
+     * @default a generated `org.inca.<slug>`
+     */
+    identifier?: string;
+    /**
+     * The app's display name.
+     * @default package.json's "name", with any npm scope stripped
+     */
+    productName?: string;
+    /**
+     * The packaged app's version.
+     * @default package.json's own "version"
+     */
+    version?: string;
+    /**
+     * The app's entry point.
+     * @default resolved automatically — a committed `src/main.mts`, or
+     * `src/App.vue` wrapped in a synthesized one
+     */
+    entry?: string;
+    /**
+     * Where a build's output is written.
+     * @default "dist"
+     */
+    outDir?: string;
+}

package/dist/config.js

@@ -0,0 +1,5 @@
+import { a as e, t } from "./chunks/defaults-EWjAFeZ3.js";
+//#region src/config/index.mts
+var n = e();
+//#endregion
+export { t as defaultConfig, n as defineConfig };

package/dist/defaultBundler.d.mts

@@ -0,0 +1,7 @@
+import { Bundler } from './adapter/types.mts';
+/**
+ * `adapter/vite` wired in as the one adapter `dev` and `build` share by
+ * default — a single place to swap bundlers, and the reason they can't
+ * drift onto different ones.
+ */
+export declare const defaultBundler: Bundler;

package/dist/dev-client/hostBin.d.mts

@@ -0,0 +1,9 @@
+/**
+ * Where `inca-host` itself lives: `INCA_HOST_BIN` if set, otherwise the
+ * per-platform npm package for this OS/arch (`@incajs/host-<os>-<arch>`, an
+ * `optionalDependency` of this package).
+ * @throws if neither resolves — no override is set, and either this
+ * platform has no published binary, or the optional dependency carrying
+ * it failed to install.
+ */
+export declare function resolveHostBin(): string;