@incajs/cli 0.0.0 → 0.0.1

package/LICENSE

@@ -0,0 +1,5 @@
+Dual-licensed under MIT OR Apache-2.0.
+
+See:
+- https://github.com/tom96da/incajs/blob/main/LICENSE-MIT
+- https://github.com/tom96da/incajs/blob/main/LICENSE-APACHE

package/README.md

@@ -1,2 +1,108 @@
-Name reservation for `@incajs/cli`; the real implementation is still in
-development. See https://github.com/tom96da/incajs.
+<!--
+Copyright (c) 2026 tom96da
+SPDX-License-Identifier: MIT OR Apache-2.0
+-->
+
+# @incajs/cli
+
+The `inca` command. Internally it wires a bundler adapter's build watch to
+a dev-protocol client talking to `inca-host` — both live inside this
+package (`src/adapter/`, `src/dev-client/`) since neither is ever imported
+on its own.
+
+`inca dev` watches an app's entry point, starts `inca-host` once the
+first bundle lands, and reloads it on every rebuild. `inca build` runs
+the same pipeline once, with the watcher removed and production settings
+on, and never starts a host. `inca package` builds the same way, then
+pairs the bundle with a prebuilt `inca-host` into a distributable
+application. `adapter/vite` is the bundler wired in by default for all
+three — swapping it for another `Bundler` (the contract `adapter/types.mts`
+defines) is a dependency change in `defaultBundler.mts`, not an edit
+anywhere else.
+
+## App entry
+
+No entry point is required. Drop a `src/App.vue` and that's a whole app —
+`inca` wraps it in `createIncaApp(App).mount()` (from `incajs/vue`)
+itself. Commit a `src/main.mts` instead for full control over
+bootstrapping; it wins outright when both exist.
+
+## `inca package`
+
+Emits a platform-native application into `dist/`: a `.app` on macOS, a
+plain directory on Linux — other platforms aren't supported yet. Either
+way, the layout puts the host binary and `bundle.js` beside each other, so
+the app launches with no arguments and no terminal.
+
+It needs a release build of the host to bundle — see `resolveHostBin`
+below for how one is found.
+
+App metadata comes from the app's own `package.json`, with an optional
+`"inca"` key overriding what's derived from it:
+
+```jsonc
+{
+  "name": "click_counter",
+  "version": "1.0.0",
+  "inca": {
+    "productName": "Click Counter", // defaults to "name", scope stripped
+    "identifier": "com.example.click-counter", // defaults to a generated org.inca.<slug>
+    "icon": "assets/icon.icns" // resolved relative to the app's own directory
+  }
+}
+```
+
+An `identifier` should be world-unique, so `inca package` prints a note
+when it falls back to the generated one rather than using it silently.
+
+## `dev-client`
+
+The Node end of the dev protocol: resolves and spawns `inca-host --dev
+<bundle>`, and speaks the newline-delimited JSON-RPC 2.0 channel it
+answers on.
+
+`HostClient` correlates each request it sends with the response that
+answers it and relays the host's stderr. Two notification methods carry
+meaning of their own: `ready`, whose `params.protocol` it checks against
+the revision it was built for, reporting and terminating the child on any
+mismatch; and `appError`, an app fault the host caught and kept rendering
+past, handed to its own callback rather than a generic one. Any other
+method name is routed, `params` untouched and unparsed, to whichever
+integration the caller registered for it.
+
+A line the host writes that doesn't parse as a JSON-RPC message is treated
+as stray output from a dependency, not a protocol violation: it's logged
+and the channel keeps reading.
+
+`resolveHostBin` tries, in order:
+
+1. `INCA_HOST_BIN`, if set — names the binary to spawn outright. This is
+   the escape hatch for a platform with no published binary yet, or a
+   custom-built one.
+2. The `optionalDependency` matching this OS/arch
+   (`@incajs/host-darwin-arm64`, `-darwin-x64`, `-linux-arm64`,
+   `-linux-x64` — Windows isn't supported yet), which almost every install
+   resolves through without either side ever needing Cargo or Rust.
+
+@throws if neither resolves.
+
+## `adapter/vite`
+
+Bundles an app's entry point into one self-contained bundle that
+`inca-host` can evaluate: no unresolved imports, no dependency on
+QuickJS having Node.js globals.
+
+`watch(options)` builds `options.entry` into a bundle under
+`options.outDir` — the returned `Watcher`'s `bundlePath` names the exact
+file — rebuilding it on every change and reporting each result through
+`options.onBuild`/`options.onError`. `build(options)` runs the same
+pipeline once, minified and with `outDir` cleared first, resolving with
+the bundle's path or rejecting on failure rather than reporting it
+through a callback.
+
+The template compiler is retargeted at `@vue/runtime-core` — the only Vue
+runtime package `incajs/vue` itself depends on — instead of the default
+`vue` import. `@vitejs/plugin-vue` itself still imports `vue` directly for
+its own internals, which is why it's a peer dependency of this package:
+that build-time need for `vue` never reaches an app's dependency tree or
+the bundle it produces.

package/bin/inca.mjs

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+// Copyright (c) 2026 tom96da
+// SPDX-License-Identifier: MIT OR Apache-2.0
+
+import { run } from "../dist/cli.js";
+
+await run();

package/dist/adapter/types.d.mts

@@ -0,0 +1,47 @@
+/** A running build watch — the value {@link Bundler.watch} resolves to. */
+export interface Watcher {
+    /** Stops watching and releases the underlying build process. */
+    close(): Promise<void>;
+}
+/** Options for {@link Bundler.watch}. */
+export interface BundlerOptions {
+    /** The app's own entry point — may import `.vue` files. */
+    entry: string;
+    /** Where the build's output is written. */
+    outDir: string;
+    /** `"development"` keeps a framework's own warnings; `"production"` strips them. */
+    mode: "development" | "production";
+    /** Called after each successful (re)build, with what it wrote. */
+    onBuild: (output: BuildOutput) => void;
+    /** Called instead of `onBuild` when a (re)build fails. */
+    onError: (error: {
+        message: string;
+        stack: string | null;
+    }) => void;
+}
+/** Options for {@link Bundler.build}. */
+export interface BuildOptions {
+    /** The app's own entry point — may import `.vue` files. */
+    entry: string;
+    /** Where the build's output is written. */
+    outDir: string;
+}
+/** What a build wrote — the result of {@link Bundler.build}, and every {@link BundlerOptions.onBuild} call. */
+export interface BuildOutput {
+    /** Directory holding every file this build emitted. */
+    outDir: string;
+    /** Absolute path to the entry module `inca-host` evaluates. */
+    entryFile: string;
+    /** Every file this build emitted, relative to `outDir` — may include chunks and assets besides the entry itself. */
+    files: readonly string[];
+}
+/**
+ * The contract a bundler adapter satisfies. Supporting another bundler
+ * means adding a sibling adapter module and injecting its `Bundler` here —
+ * never editing this package's own types.
+ */
+export interface Bundler {
+    watch(options: BundlerOptions): Promise<Watcher>;
+    /** One-shot production build, used by `inca build` — rejects on failure. */
+    build(options: BuildOptions): Promise<BuildOutput>;
+}

package/dist/adapter/vite/build.d.mts

@@ -0,0 +1,8 @@
+import { BuildOptions, BuildOutput } from '../types.mts';
+export type { BuildOptions, BuildOutput } from '../types.mts';
+/**
+ * Builds `entry` into a minified, production build under `outDir` once, and
+ * rejects on failure rather than reporting it through a callback. Never
+ * starts or talks to `inca-host` — that's `dev.mts`'s job.
+ */
+export declare function build({ entry, outDir }: BuildOptions): Promise<BuildOutput>;

package/dist/adapter/vite/captureOutput.d.mts

@@ -0,0 +1,15 @@
+import { Plugin } from 'vite';
+/** What one (re)build actually wrote, relative to its own `outDir`. */
+export interface CapturedOutput {
+    /** The emitted chunk marked as this build's entry. */
+    entryFile: string;
+    /** Every emitted file, as the bundler reported it. */
+    files: readonly string[];
+}
+/**
+ * A Vite plugin reporting `sink` the files a build wrote once they land on
+ * disk, via `writeBundle` — the one hook that fires uniformly for a
+ * one-shot build and every watch rebuild, so both read the bundler's real
+ * output instead of assuming a file name or layout.
+ */
+export declare function captureOutput(sink: (output: CapturedOutput) => void): Plugin;

package/dist/adapter/vite/config.d.mts

@@ -0,0 +1,26 @@
+import { InlineConfig } from 'vite';
+import { CapturedOutput } from './captureOutput.mts';
+export declare const BUNDLE_FILE_NAME = "bundle.js";
+export interface ResolveConfigOptions {
+    /** The app's own entry point — may import `.vue` files. */
+    entry: string;
+    /** Where the build's output is written. */
+    outDir: string;
+    /** `"development"` keeps `@vue/runtime-core`'s own warnings; `"production"` strips them. */
+    mode: "development" | "production";
+    /** Whether Vite should keep rebuilding on file changes. */
+    watch: boolean;
+    /** Called with what each successful (re)build wrote. */
+    onOutput: (output: CapturedOutput) => void;
+}
+/**
+ * Builds the Vite config shared by `watch` and `build`, compiling `.vue`
+ * files via `@vitejs/plugin-vue` targeted at `@vue/runtime-core` rather than
+ * the `vue` meta-package it requires to run.
+ *
+ * An import the entry doesn't inline — a dynamic `import()`, or a `.vue`
+ * file's own `<style>` block — lands as its own chunk or asset alongside
+ * the entry, named by `chunkFileNames`/`assetFileNames` below, rather than
+ * failing the build.
+ */
+export declare function resolveViteConfig({ entry, outDir, mode, watch, onOutput, }: ResolveConfigOptions): InlineConfig;

package/dist/adapter/vite/index.d.mts

@@ -0,0 +1,2 @@
+export { build } from './build.mts';
+export { watch } from './watch.mts';

package/dist/adapter/vite/watch.d.mts

@@ -0,0 +1,8 @@
+import { BundlerOptions, Watcher } from '../types.mts';
+export type { Watcher } from '../types.mts';
+/**
+ * Builds `entry` into a build under `outDir` and rebuilds it on every
+ * change, calling `onBuild` with what each rebuild wrote. Never starts,
+ * reloads, or talks to `inca-host` — that's `dev.mts`'s job.
+ */
+export declare function watch({ onBuild, onError, ...buildOptions }: BundlerOptions): Promise<Watcher>;

package/dist/build.d.mts

@@ -0,0 +1,18 @@
+import { Bundler, BuildOutput } from './adapter/types.mts';
+export interface BuildAppOptions {
+    /** The app's root directory. Defaults to `process.cwd()`. */
+    cwd?: string;
+    /**
+     * The app's entry point. Defaults to resolving it automatically: a
+     * committed `src/main.mts`, or `src/App.vue` wrapped in a synthesized one.
+     */
+    entry?: string;
+    /** Overrides the bundler — see {@link defaultBundler} for what's wired in by default. */
+    bundler?: Bundler;
+}
+/**
+ * Builds the app once through the same bundler `dev` uses, and returns what
+ * it wrote. Rejects on failure — deciding what that means for the process
+ * is `cli.mts`'s job.
+ */
+export declare function build(options?: BuildAppOptions): Promise<BuildOutput>;

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,481 @@
+import e from "node:path";
+import { build as t } from "vite";
+import n from "@vitejs/plugin-vue";
+import { existsSync as r } from "node:fs";
+import { chmod as i, cp as a, mkdir as o, readFile as s, readdir as c, rm as l, writeFile as u } from "node:fs/promises";
+import { createRequire as d } from "node:module";
+import { spawn as f } from "node:child_process";
+import { once as p } from "node:events";
+import m from "node:readline";
+import { setTimeout as h } from "node:timers/promises";
+//#region src/adapter/vite/captureOutput.mts
+function g(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 _ = "bundle.js";
+function v({ entry: t, outDir: r, mode: i, watch: a, onOutput: o }) {
+	return {
+		configFile: !1,
+		root: e.dirname(t),
+		mode: i,
+		clearScreen: !1,
+		logLevel: "silent",
+		define: { "process.env.NODE_ENV": JSON.stringify(i) },
+		plugins: [n({ template: { compilerOptions: { runtimeModuleName: "@vue/runtime-core" } } }), g(o)],
+		build: {
+			lib: {
+				entry: t,
+				formats: ["es"],
+				fileName: () => _
+			},
+			outDir: r,
+			emptyOutDir: i === "production",
+			minify: i === "production",
+			watch: a ? {} : void 0,
+			rolldownOptions: { output: {
+				chunkFileNames: "chunks/[name]-[hash].js",
+				assetFileNames: "assets/[name]-[hash][extname]"
+			} }
+		}
+	};
+}
+//#endregion
+//#region src/adapter/vite/build.mts
+async function y({ entry: n, outDir: r }) {
+	let i;
+	if (await t(v({
+		entry: n,
+		outDir: r,
+		mode: "production",
+		watch: !1,
+		onOutput: (t) => {
+			i = {
+				outDir: r,
+				entryFile: e.join(r, t.entryFile),
+				files: t.files
+			};
+		}
+	})), !i) throw Error("inca: build produced no output");
+	return i;
+}
+//#endregion
+//#region src/adapter/vite/watch.mts
+async function b({ onBuild: n, onError: r, ...i }) {
+	let { outDir: a } = i, o = await t(v({
+		...i,
+		watch: !0,
+		onOutput: (t) => {
+			n({
+				outDir: a,
+				entryFile: e.join(a, t.entryFile),
+				files: t.files
+			});
+		}
+	}));
+	return o.on("event", (e) => {
+		e.code === "ERROR" && r({
+			message: e.error.message,
+			stack: e.error.stack ?? null
+		});
+	}), { close: () => o.close() };
+}
+//#endregion
+//#region src/defaultBundler.mts
+var x = {
+	watch: b,
+	build: y
+};
+//#endregion
+//#region src/entry.mts
+async function S(t) {
+	let n = e.join(t, "src/main.mts");
+	if (r(n)) return n;
+	let i = e.join(t, "src/App.vue");
+	if (r(i)) return C(i, t);
+	throw Error(`no app entry found — expected ${n} or ${i}`);
+}
+async function C(t, n) {
+	let r = e.join(n, "node_modules/.inca");
+	await o(r, { recursive: !0 });
+	let i = e.join(r, "entry.mts"), a = JSON.stringify(t.split(e.sep).join("/"));
+	return await u(i, `import { createIncaApp } from "incajs/vue";\nimport App from ${a};\ncreateIncaApp(App).mount();\n`), i;
+}
+//#endregion
+//#region src/build.mts
+async function w(t = {}) {
+	let n = t.cwd ?? process.cwd(), r = e.join(n, "dist"), i = t.bundler ?? x, a = t.entry ?? await S(n);
+	return i.build({
+		entry: a,
+		outDir: r
+	});
+}
+//#endregion
+//#region src/dev-client/hostBin.mts
+var T = "INCA_HOST_BIN";
+function E() {
+	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 D() {
+	let e = E();
+	if (e) try {
+		return d(import.meta.url).resolve(`${e}/bin/inca-host`);
+	} catch {
+		return;
+	}
+}
+function O() {
+	let e = process.env[T];
+	if (e) return e;
+	let t = D();
+	if (t) return t;
+	let n = E(), 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 ${T} isn't set to one`);
+}
+//#endregion
+//#region src/dev-client/hostError.mts
+var k = class extends Error {
+	code;
+	hostStack;
+	constructor(e, t, n = null) {
+		super(e), this.code = t, this.hostStack = n, this.name = "HostError";
+	}
+};
+function A(e) {
+	return typeof e == "object" && !!e && e.jsonrpc === "2.0";
+}
+//#endregion
+//#region src/dev-client/hostClient.mts
+var j = (e) => {
+	process.stderr.write(e.endsWith("\n") ? e : `${e}\n`);
+}, M = class {
+	#e;
+	#t;
+	#n = 1;
+	#r = /* @__PURE__ */ new Map();
+	constructor(e) {
+		this.#e = e;
+	}
+	async start() {
+		let e = this.#e.hostBin ?? O(), t = f(e, ["--dev", this.#e.entryFile], { stdio: [
+			"pipe",
+			"pipe",
+			"pipe"
+		] });
+		this.#t = t;
+		let n = this.#e.onStderr ?? j;
+		t.stderr.setEncoding("utf8"), t.stderr.on("data", (e) => n(e)), m.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 p(t, "spawn");
+	}
+	#i(e, t) {
+		let n;
+		try {
+			n = JSON.parse(e);
+		} catch {
+			t(`[stray stdout] ${e}`);
+			return;
+		}
+		if (!A(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 k(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 = p(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 = p(t, "exit");
+		this.call("shutdown").catch(() => {}), await Promise.race([n.then(() => "exited"), h(e).then(() => "timeout")]) === "timeout" && (t.kill(), await n);
+	}
+};
+//#endregion
+//#region src/fault.mts
+function N(e) {
+	return e instanceof k ? {
+		message: e.message,
+		stack: e.hostStack
+	} : e instanceof Error ? {
+		message: e.message,
+		stack: e.stack ?? null
+	} : {
+		message: String(e),
+		stack: null
+	};
+}
+function P(e, t, n) {
+	e.write(`[inca] ${t}: ${n.message}\n`), n.stack && e.write(`${n.stack}\n`);
+}
+//#endregion
+//#region src/dev.mts
+async function F(t, n) {
+	let r = new Set(n), i;
+	try {
+		i = await c(t, {
+			recursive: !0,
+			withFileTypes: !0
+		});
+	} catch {
+		return;
+	}
+	await Promise.all(i.filter((e) => e.isFile()).map((n) => e.relative(t, e.join(n.parentPath, n.name))).filter((e) => !r.has(e)).map((n) => l(e.join(t, n), { force: !0 })));
+}
+async function I(t) {
+	let n = t.cwd ?? process.cwd(), r = e.join(n, "dist"), i = t.bundler ?? x, a = t.stdout ?? process.stdout, o = t.stderr ?? process.stderr, s = t.entry ?? await S(n), c, l = !1, u = !1, d = Promise.resolve();
+	async function f() {
+		try {
+			await c?.call("reload");
+		} catch (e) {
+			P(o, "reload failed", N(e));
+		}
+	}
+	async function p(e) {
+		if (await F(e.outDir, e.files), !c) {
+			let n = new M({
+				entryFile: e.entryFile,
+				hostBin: t.hostBin,
+				onStderr: (e) => o.write(e),
+				onReady: () => {
+					l = !0, a.write("[inca] ready\n"), u && (u = !1, f());
+				},
+				onAppError: (e) => P(o, "app error", e)
+			});
+			try {
+				await n.start();
+			} catch (e) {
+				P(o, "failed to start inca-host", N(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) => {
+			P(o, "build failed", e);
+		}
+	});
+	await new Promise((e) => {
+		if (t.signal.aborted) {
+			e();
+			return;
+		}
+		t.signal.addEventListener("abort", () => e(), { once: !0 });
+	}), await d, await c?.stop(), await m.close();
+}
+//#endregion
+//#region src/metadata.mts
+function L(e) {
+	let t = e.indexOf("/");
+	return e.startsWith("@") && t !== -1 ? e.slice(t + 1) : e;
+}
+function R(e) {
+	return e.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+async function z(t) {
+	let n = e.join(t, "package.json"), i;
+	try {
+		i = await s(n, "utf8");
+	} catch {
+		throw Error(`no package.json found at ${n}`);
+	}
+	let a = JSON.parse(i), o = a.inca ?? {}, c = o.productName ?? (a.name ? L(a.name) : void 0);
+	if (!c) throw Error(`${n} needs a "name", or "inca": { "productName" }`);
+	let l = a.version ?? "0.0.0", u = o.identifier ?? `org.inca.${R(c)}`, d;
+	if (o.icon && (d = e.resolve(t, o.icon), !r(d))) throw Error(`"inca.icon" points to ${d}, which doesn't exist`);
+	return {
+		productName: c,
+		identifier: u,
+		identifierIsDefault: o.identifier === void 0,
+		version: l,
+		icon: d
+	};
+}
+//#endregion
+//#region src/plist.mts
+function B(e) {
+	return e.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+function V(e) {
+	return typeof e == "boolean" ? e ? "<true/>" : "<false/>" : `<string>${B(e)}</string>`;
+}
+function H(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>${B(e)}</key>\n\t${V(t)}`).join("\n")}\n</dict>
+</plist>
+`;
+}
+//#endregion
+//#region src/package.mts
+function U() {
+	if (process.platform === "darwin") return "macos";
+	if (process.platform === "linux") return "linux";
+	throw Error(`inca package doesn't support ${process.platform} yet`);
+}
+async function W(t, n) {
+	await Promise.all(t.files.map(async (r) => {
+		let i = e.join(n, r);
+		await o(e.dirname(i), { recursive: !0 }), await a(e.join(t.outDir, r), i);
+	}));
+}
+async function G({ metadata: t, output: n, hostBin: r }) {
+	let s = e.join(n.outDir, `${t.productName}.app`);
+	await l(s, {
+		recursive: !0,
+		force: !0
+	});
+	let c = e.join(s, "Contents"), d = e.join(c, "MacOS"), f = e.join(c, "Resources");
+	await o(d, { recursive: !0 }), await o(f, { recursive: !0 });
+	let p = e.join(d, t.productName);
+	await a(r, p), await i(p, 493), await W(n, f);
+	let m = {
+		CFBundleName: t.productName,
+		CFBundleDisplayName: t.productName,
+		CFBundleExecutable: t.productName,
+		CFBundleIdentifier: t.identifier,
+		CFBundleVersion: t.version,
+		CFBundleShortVersionString: t.version,
+		CFBundlePackageType: "APPL",
+		CFBundleInfoDictionaryVersion: "6.0",
+		NSHighResolutionCapable: !0
+	};
+	if (t.icon) {
+		let n = e.basename(t.icon);
+		await a(t.icon, e.join(f, n)), m.CFBundleIconFile = n;
+	}
+	return await u(e.join(c, "Info.plist"), H(m)), await u(e.join(c, "PkgInfo"), "APPL????"), s;
+}
+async function K({ metadata: t, output: n, hostBin: r }) {
+	let s = R(t.productName), c = e.join(n.outDir, s);
+	await l(c, {
+		recursive: !0,
+		force: !0
+	}), await o(c, { recursive: !0 });
+	let u = e.join(c, s);
+	return await a(r, u), await i(u, 493), await W(n, c), c;
+}
+async function q(e = {}) {
+	let t = e.cwd ?? process.cwd(), n = e.stdout ?? process.stdout, i = e.target ?? U(), a = await z(t);
+	a.identifierIsDefault && n.write(`[inca] no "inca.identifier" set in package.json — using generated identifier ${a.identifier}\n`);
+	let o = await w({
+		cwd: t,
+		entry: e.entry,
+		bundler: e.bundler
+	}), s = e.hostBin ?? O();
+	if (!r(s)) throw Error(`no host binary at ${s} — check that it was built and is executable`);
+	let c = {
+		metadata: a,
+		output: o,
+		hostBin: s
+	};
+	return { appPath: i === "macos" ? await G(c) : await K(c) };
+}
+//#endregion
+//#region src/cli.mts
+var J = "Usage: inca <dev|build|package>";
+async function Y(e = process.argv) {
+	let t = e[2];
+	if (t === "build") {
+		try {
+			let e = await w();
+			process.stdout.write(`[inca] built ${e.entryFile}\n`);
+		} catch (e) {
+			P(process.stderr, "build failed", N(e)), process.exitCode = 1;
+		}
+		return;
+	}
+	if (t === "package") {
+		try {
+			let { appPath: e } = await q();
+			process.stdout.write(`[inca] packaged ${e}\n`);
+		} catch (e) {
+			P(process.stderr, "package failed", N(e)), process.exitCode = 1;
+		}
+		return;
+	}
+	if (t !== "dev") {
+		process.stderr.write(`${J}\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 I({ signal: n.signal });
+}
+//#endregion
+export { Y as run };

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;

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

@@ -0,0 +1,50 @@
+import { AppErrorParams } from './protocol.mts';
+export interface HostClientOptions {
+    /** The entry module passed to the host as `--dev <entryFile>`. */
+    entryFile: string;
+    /** Overrides which `inca-host` binary gets spawned, in place of automatic resolution. */
+    hostBin?: string;
+    /**
+     * Every diagnostic line the transport itself produces: the host's real
+     * stderr, a stray stdout line, and a `ready` protocol mismatch. Defaults
+     * to this process's own stderr.
+     */
+    onStderr?: (line: string) => void;
+    /**
+     * The window is up and the first bundle has been evaluated, and the host
+     * speaks the protocol revision this package was built for.
+     */
+    onReady?: () => void;
+    /** An app's own event listener threw; the host caught it and kept rendering. */
+    onAppError?: (error: AppErrorParams) => void;
+    /**
+     * Handlers for notification `method`s this package doesn't implement
+     * itself (e.g. a future Vite integration), keyed by method name —
+     * `params` forwarded untouched.
+     */
+    integrations?: Record<string, (params: unknown) => void>;
+}
+/**
+ * Spawns `inca-host --dev <entryFile>` and speaks newline-delimited
+ * JSON-RPC 2.0 on its stdin/stdout. One instance owns exactly one child
+ * process for its whole lifetime — a reload is a `reload` call on the same
+ * child, never a respawn.
+ */
+export declare class HostClient {
+    #private;
+    constructor(options: HostClientOptions);
+    /**
+     * Starts the child and wires up its streams. Resolves once the process
+     * has actually spawned; rejects if it never does (e.g. the resolved
+     * binary doesn't exist).
+     */
+    start(): Promise<void>;
+    /** Sends a request and resolves with its result once the host answers. */
+    call(method: string, params?: unknown): Promise<unknown>;
+    /**
+     * Asks the host to `shutdown` and waits for the child to actually exit —
+     * that exit is the real acknowledgement, not the response. Kills it once
+     * `timeoutMs` passes without that, so a wedged app can't block teardown.
+     */
+    stop(timeoutMs?: number): Promise<void>;
+}

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

@@ -0,0 +1,6 @@
+/** A fault the host answered a request with, carrying its JSON-RPC code. */
+export declare class HostError extends Error {
+    readonly code: number;
+    readonly hostStack: string | null;
+    constructor(message: string, code: number, hostStack?: string | null);
+}

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

@@ -0,0 +1,4 @@
+export { resolveHostBin } from './hostBin.mts';
+export { HostError } from './hostError.mts';
+export { HostClient } from './hostClient.mts';
+export type { HostClientOptions } from './hostClient.mts';

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

@@ -0,0 +1,38 @@
+export declare const JSONRPC = "2.0";
+/**
+ * The host method-set revision this package expects, checked against
+ * `ready`'s `params.protocol` — a mismatch means an incompatible host
+ * build.
+ */
+export declare const HOST_PROTOCOL_VERSION = 0;
+/** `ready`'s notification params. */
+export interface ReadyParams {
+    protocol: number;
+}
+/** `appError`'s notification params. */
+export interface AppErrorParams {
+    message: string;
+    stack: string | null;
+}
+export interface RpcResult {
+    jsonrpc: typeof JSONRPC;
+    id: number;
+    result: unknown;
+}
+export interface RpcFailure {
+    jsonrpc: typeof JSONRPC;
+    id: number;
+    error: {
+        code: number;
+        message: string;
+        data?: {
+            stack: string | null;
+        };
+    };
+}
+export interface RpcNotification {
+    jsonrpc: typeof JSONRPC;
+    method: string;
+    params: unknown;
+}
+export declare function isRpcMessage(value: unknown): value is RpcResult | RpcFailure | RpcNotification;

package/dist/dev.d.mts

@@ -0,0 +1,25 @@
+import { Bundler } from './adapter/types.mts';
+export interface DevOptions {
+    /** The app's root directory. Defaults to `process.cwd()`. */
+    cwd?: string;
+    /**
+     * The app's entry point. Defaults to resolving it automatically: a
+     * committed `src/main.mts`, or `src/App.vue` wrapped in a synthesized one.
+     */
+    entry?: string;
+    /** Overrides the bundler — see {@link defaultBundler} for what's wired in by default. */
+    bundler?: Bundler;
+    /** Overrides host binary resolution — passed straight through to `HostClient`. */
+    hostBin?: string;
+    /** Defaults to `process.stdout`. */
+    stdout?: NodeJS.WritableStream;
+    /** Defaults to `process.stderr`. */
+    stderr?: NodeJS.WritableStream;
+    /** Aborting tears the host and the bundler watcher down and resolves `dev()`. */
+    signal: AbortSignal;
+}
+/**
+ * Builds the app, starts `inca-host` once the first build lands, and
+ * reloads it on every rebuild — until `options.signal` aborts.
+ */
+export declare function dev(options: DevOptions): Promise<void>;

package/dist/entry.d.mts

@@ -0,0 +1,8 @@
+/**
+ * Resolves an app's entry point. `src/main.mts`, committed by the app,
+ * wins outright and is used verbatim — full control over bootstrapping.
+ * Otherwise `src/App.vue` is wrapped in a synthesized entry equivalent to
+ * `createIncaApp(App).mount()`, so a plain `.vue` file is a whole app
+ * with no configuration at all.
+ */
+export declare function resolveEntry(cwd: string): Promise<string>;

package/dist/fault.d.mts

@@ -0,0 +1,6 @@
+export interface Fault {
+    message: string;
+    stack: string | null;
+}
+export declare function toFault(error: unknown): Fault;
+export declare function printFault(stream: NodeJS.WritableStream, label: string, fault: Fault): void;

package/dist/index.d.mts

@@ -0,0 +1 @@
+export type { BuildOptions, BuildOutput, Bundler, BundlerOptions, Watcher, } from './adapter/types.mts';

package/dist/metadata.d.mts

@@ -0,0 +1,30 @@
+/** An app's identity and version, for `inca package` to stamp onto the application it emits. */
+export interface AppMetadata {
+    /** Shown to the user — the app's display name. */
+    productName: string;
+    /** A reverse-DNS-style unique id — e.g. macOS's `CFBundleIdentifier`. */
+    identifier: string;
+    /** True when `identifier` was derived rather than set by the app. */
+    identifierIsDefault: boolean;
+    /** The packaged app's version. */
+    version: string;
+    /** Absolute path to an icon file, if the app declared one. */
+    icon?: string;
+}
+/**
+ * Turns a display name into a filesystem/URL-safe slug — lowercased, with
+ * anything outside `[a-z0-9]` collapsed into a single `-`. Used for the
+ * default `identifier` and for the Linux packaged-app directory name.
+ */
+export declare function slugify(name: string): string;
+/**
+ * Reads an app's package metadata for `inca package`: `productName`,
+ * `identifier`, `version`, and an optional `icon`. Everything is derived
+ * from the app's own `package.json` — its `name`/`version` fields, and an
+ * optional `"inca"` key overriding any of them:
+ * `{ "inca": { "productName", "identifier", "icon" } }`.
+ *
+ * @throws if `package.json` is missing, has neither a `name` nor a
+ * `"inca".productName`, or `"inca".icon` doesn't resolve to a real file.
+ */
+export declare function readAppMetadata(cwd: string): Promise<AppMetadata>;

package/dist/package.d.mts

@@ -0,0 +1,45 @@
+import { Bundler } from './adapter/types.mts';
+/** A platform `inca package` can emit a distributable application for. */
+export type PackageTarget = "macos" | "linux";
+/** Options for {@link packageApp}. */
+export interface PackageAppOptions {
+    /** The app's root directory. Defaults to `process.cwd()`. */
+    cwd?: string;
+    /**
+     * The app's entry point. Defaults to resolving it the same way `inca
+     * dev`/`build` do: a committed `src/main.mts`, or `src/App.vue` wrapped
+     * in a synthesized one.
+     */
+    entry?: string;
+    /** Overrides the bundler — see {@link build}'s default. */
+    bundler?: Bundler;
+    /**
+     * Overrides which `inca-host` binary gets embedded in the packaged
+     * app, in place of automatic resolution (`INCA_HOST_BIN`, then the
+     * per-platform `@incajs/host-*` package — see {@link resolveHostBin}).
+     */
+    hostBin?: string;
+    /**
+     * The platform to package for. Defaults to whichever one the current
+     * process is running on.
+     */
+    target?: PackageTarget;
+    /** Where progress notes go. Defaults to `process.stdout`. */
+    stdout?: NodeJS.WritableStream;
+}
+/** The result of a successful {@link packageApp} call. */
+export interface PackageResult {
+    /** The packaged app's path — a `.app` directory on macOS, a plain directory on Linux. */
+    appPath: string;
+}
+/**
+ * Builds the app and pairs it with the prebuilt `inca-host` into a
+ * distributable, platform-native application — a `.app` on macOS, a plain
+ * directory on Linux — written alongside the build output, under the
+ * app's own `dist/`. The app launches with no arguments and no terminal,
+ * since `inca-host` finds its own bundle beside its executable.
+ *
+ * @throws if the app's metadata can't be read, the build fails, or no
+ * `inca-host` binary can be resolved for the target platform.
+ */
+export declare function packageApp(options?: PackageAppOptions): Promise<PackageResult>;

package/dist/plist.d.mts

@@ -0,0 +1,4 @@
+/** A macOS `Info.plist`'s value types — the only ones `inca package` writes. */
+export type PlistValue = string | boolean;
+/** Encodes a flat key/value dict as an `Info.plist` XML document. */
+export declare function encodePlist(dict: Record<string, PlistValue>): string;

package/package.json

@@ -1,16 +1,19 @@
 {
   "name": "@incajs/cli",
-  "version": "0.0.0",
-  "description": "Incarnative.js — the `inca` CLI (dev/build/package). Name reservation; the real implementation is still in development.",
+  "version": "0.0.1",
+  "description": "The inca CLI: watches an app's entry point through a bundler adapter, starts inca-host once the first bundle lands, and reloads it on every rebuild.",
   "keywords": [
     "bundler",
     "cli",
     "desktop-app",
+    "dev-server",
     "gpui",
     "gui",
     "incajs",
     "incarnative.js",
-    "quickjs"
+    "json-rpc",
+    "quickjs",
+    "vite"
   ],
   "license": "(MIT OR Apache-2.0)",
   "repository": {
@@ -18,7 +21,59 @@
     "url": "git+https://github.com/tom96da/incajs.git",
     "directory": "packages/cli"
   },
+  "bin": {
+    "inca": "./bin/inca.mjs"
+  },
+  "files": [
+    "dist",
+    "bin"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.js"
+    }
+  },
   "publishConfig": {
     "access": "public"
+  },
+  "dependencies": {
+    "@vitejs/plugin-vue": "^6.0.8",
+    "vite": "^8.2.2"
+  },
+  "devDependencies": {
+    "@types/node": "^26.4.1",
+    "@vue/runtime-core": "^3.5.42",
+    "oxfmt": "^0.66.0",
+    "oxlint": "^1.81.0",
+    "rolldown": "~1.2.4",
+    "vue": "^3.5.42"
+  },
+  "peerDependencies": {
+    "vue": "^3.5.42"
+  },
+  "peerDependenciesMeta": {
+    "vue": {
+      "optional": true
+    }
+  },
+  "optionalDependencies": {
+    "@incajs/host-darwin-arm64": "0.0.1",
+    "@incajs/host-linux-arm64": "0.0.1",
+    "@incajs/host-linux-x64": "0.0.1"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "scripts": {
+    "build": "vite build",
+    "test": "vitest run",
+    "lint": "oxlint --type-aware",
+    "format": "oxfmt --check .",
+    "typecheck": "oxlint -A all --type-aware --type-check"
   }
 }