@incajs/cli 0.0.0 → 0.0.2

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,2 @@
+export type { BuildOptions, BuildOutput, Bundler, BundlerOptions, Watcher, } from './adapter/types.mts';
+export type { ResolvedAppConfig } from './config/loader.mts';

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,24 +1,85 @@
 {
   "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.2",
+  "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"
   ],
+  "homepage": "https://tom96da.github.io/incajs/",
   "license": "(MIT OR Apache-2.0)",
   "repository": {
     "type": "git",
     "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"
+    },
+    "./config": {
+      "types": "./dist/config/index.d.mts",
+      "import": "./dist/config.js"
+    }
+  },
   "publishConfig": {
     "access": "public"
+  },
+  "dependencies": {
+    "@vitejs/plugin-vue": "^6.0.9",
+    "vite": "^8.3.0"
+  },
+  "devDependencies": {
+    "@types/node": "^26.6.2",
+    "@vue/runtime-core": "^3.5.43",
+    "c12": "4.0.0-rc.1",
+    "oxfmt": "^0.68.0",
+    "oxlint": "^1.83.0",
+    "rolldown": "~1.2.9",
+    "vue": "^3.5.43"
+  },
+  "peerDependencies": {
+    "vue": "^3.5.43"
+  },
+  "peerDependenciesMeta": {
+    "vue": {
+      "optional": true
+    }
+  },
+  "optionalDependencies": {
+    "@incajs/host-darwin-arm64": "0.0.2",
+    "@incajs/host-linux-arm64": "0.0.2",
+    "@incajs/host-linux-x64": "0.0.2"
+  },
+  "engines": {
+    "node": ">=22.18"
+  },
+  "scripts": {
+    "build": "vite build",
+    "test": "vitest run",
+    "lint": "oxlint --type-aware",
+    "format": "oxfmt --check .",
+    "typecheck": "oxlint -A all --type-aware --type-check"
   }
 }