@octane-xplat/cli 0.1.0

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@octane-xplat/cli",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "xplat — dev/build/doctor for octane-xplat apps (web + iOS + Android from one codebase)",
+  "bin": {
+    "xplat": "./src/cli.mjs"
+  },
+  "files": [
+    "src"
+  ],
+  "dependencies": {
+    "@alloc/cmd-ts": "0.17.1",
+    "@clack/prompts": "1.8.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/cli.mjs

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+import { binary, subcommands, run } from '@alloc/cmd-ts';
+import { dev } from './commands/dev.mjs';
+import { build } from './commands/build.mjs';
+import { typecheck } from './commands/typecheck.mjs';
+import { doctor } from './commands/doctor.mjs';
+import { clean } from './commands/clean.mjs';
+
+const cli = subcommands({
+	name: 'xplat',
+	description: 'One Octane codebase → web + iOS + Android',
+	cmds: { dev, build, typecheck, doctor, clean },
+});
+
+await run(binary(cli), process.argv);

package/src/commands/build.mjs

@@ -0,0 +1,57 @@
+import { command, flag, option, optional, string } from '@alloc/cmd-ts';
+import * as p from '@clack/prompts';
+import { buildTargets } from '../targets.mjs';
+import { runTagged } from '../procs.mjs';
+
+export const build = command({
+	name: 'build',
+	description: 'Build for web, iOS, Android',
+	args: {
+		release: flag({ long: 'release', description: 'Native release builds (signed where configured)' }),
+		targets: option({
+			long: 'targets',
+			short: 't',
+			type: optional(string),
+			description: 'Comma list (web,ios,android) — skips the prompt',
+		}),
+	},
+	handler: async (args) => {
+		const cwd = process.cwd();
+		const all = buildTargets(cwd);
+		if (all.length === 0) {
+			p.log.error('Nothing to build — no vite.config.ts or nativescript.config.ts found.');
+			process.exit(1);
+		}
+
+		let chosen;
+		if (args.targets) {
+			const kinds = args.targets.split(',').map((s) => s.trim());
+			chosen = all.filter((t) => kinds.includes(t.kind));
+		} else if (!process.stdout.isTTY) {
+			chosen = all;
+		} else {
+			p.intro('xplat build');
+			const picked = await p.multiselect({
+				message: 'Build targets',
+				options: all.map((t) => ({ value: t.id, label: t.name })),
+				initialValues: all.map((t) => t.id),
+				required: true,
+			});
+			if (p.isCancel(picked)) { p.cancel('Cancelled'); process.exit(0); }
+			chosen = all.filter((t) => picked.includes(t.id));
+		}
+
+		for (const t of chosen) {
+			const argv = t.kind === 'web'
+				? ['exec', 'vite', 'build']
+				: ['exec', 'ns', 'build', t.kind, ...(args.release ? ['--release'] : [])];
+			try {
+				await runTagged(t.kind, 'pnpm', argv, cwd);
+			} catch (e) {
+				p.log.error(String(e));
+				process.exit(1);
+			}
+		}
+		p.log.success('Build complete');
+	},
+});

package/src/commands/clean.mjs

@@ -0,0 +1,23 @@
+import { command } from '@alloc/cmd-ts';
+import { existsSync, rmSync } from 'node:fs';
+import * as p from '@clack/prompts';
+
+const DIRS = ['dist', 'platforms', '.ns-vite-build', 'node_modules/.vite'];
+
+export const clean = command({
+	name: 'clean',
+	description: 'Remove build outputs (dist, platforms, vite caches)',
+	args: {},
+	handler: async () => {
+		const cwd = process.cwd();
+		const found = DIRS.filter((d) => existsSync(`${cwd}/${d}`));
+		if (found.length === 0) { p.log.info('Nothing to clean'); return; }
+
+		if (process.stdout.isTTY) {
+			const ok = await p.confirm({ message: `Remove ${found.join(', ')}?` });
+			if (p.isCancel(ok) || !ok) { p.cancel('Cancelled'); return; }
+		}
+		for (const d of found) rmSync(`${cwd}/${d}`, { recursive: true, force: true });
+		p.log.success(`Cleaned ${found.join(', ')}`);
+	},
+});

package/src/commands/dev.mjs

@@ -0,0 +1,55 @@
+import { command, option, optional, string } from '@alloc/cmd-ts';
+import * as p from '@clack/prompts';
+import { discoverTargets } from '../targets.mjs';
+import { spawnTagged } from '../procs.mjs';
+
+const spawnFor = (t, cwd) =>
+	t.kind === 'web'
+		? spawnTagged('web', 'pnpm', ['exec', 'vite'], cwd)
+		: spawnTagged(t.kind, 'pnpm', ['exec', 'ns', 'run', t.kind, '--device', t.device], cwd);
+
+export const dev = command({
+	name: 'dev',
+	description: 'Run dev servers — web, iOS simulators, Android emulators/devices',
+	args: {
+		targets: option({
+			long: 'targets',
+			short: 't',
+			type: optional(string),
+			description: 'Comma list (web,ios,android) — skips the prompt',
+		}),
+	},
+	handler: async (args) => {
+		const cwd = process.cwd();
+		const all = discoverTargets(cwd);
+		if (all.length === 0) {
+			p.log.error('No targets found — need vite.config.ts (web) or nativescript.config.ts (native).');
+			process.exit(1);
+		}
+
+		let chosen;
+		if (args.targets) {
+			const kinds = args.targets.split(',').map((s) => s.trim());
+			chosen = all.filter((t) => kinds.includes(t.kind));
+			if (chosen.length === 0) {
+				p.log.error(`No targets matched "${args.targets}". Available: ${all.map((t) => t.kind).join(', ')}`);
+				process.exit(1);
+			}
+		} else if (!process.stdout.isTTY) {
+			chosen = all; // non-interactive: everything detected
+		} else {
+			p.intro('xplat dev');
+			const picked = await p.multiselect({
+				message: 'Dev targets',
+				options: all.map((t) => ({ value: t.id, label: t.name })),
+				initialValues: all.map((t) => t.id),
+				required: true,
+			});
+			if (p.isCancel(picked)) { p.cancel('Cancelled'); process.exit(0); }
+			chosen = all.filter((t) => picked.includes(t.id));
+		}
+
+		for (const t of chosen) spawnFor(t, cwd);
+		p.log.success(`${chosen.length} target(s) running — Ctrl+C stops all`);
+	},
+});

package/src/commands/doctor.mjs

@@ -0,0 +1,48 @@
+import { command } from '@alloc/cmd-ts';
+import { execFileSync } from 'node:child_process';
+import * as p from '@clack/prompts';
+
+const check = (cmd, args) => {
+	try {
+		return { ok: true, out: execFileSync(cmd, args, { encoding: 'utf8', timeout: 15000, stdio: ['ignore', 'pipe', 'pipe'] }).trim().split('\n')[0] };
+	} catch {
+		return { ok: false, out: '' };
+	}
+};
+
+/** env checks — the things that have actually bitten this stack. */
+export const doctor = command({
+	name: 'doctor',
+	description: 'Check the toolchain for web + native builds',
+	args: {},
+	handler: async () => {
+		p.intro('xplat doctor');
+		const rows = [];
+		const row = (name, ok, detail, hint) => rows.push({ name, ok, detail, hint });
+
+		row('node', check('node', ['--version']).ok, check('node', ['--version']).out);
+		row('pnpm', check('pnpm', ['--version']).ok, check('pnpm', ['--version']).out);
+		row('ns CLI', check('pnpm', ['exec', 'ns', '--version']).ok, check('pnpm', ['exec', 'ns', '--version']).out,
+			'add the nativescript devDep (the starter ships it)');
+		row('xcodebuild', check('xcodebuild', ['-version']).ok, check('xcodebuild', ['-version']).out,
+			'iOS needs Xcode — App Store install + xcode-select');
+		row('xcodeproj gem', check('ruby', ['-e', 'require "xcodeproj"']).ok, '',
+			'gem install --user-install xcodeproj');
+		const sims = check('xcrun', ['simctl', 'list', 'devices', 'booted']);
+		row('iOS simulator', sims.ok, sims.out || 'none booted');
+		const adb = check('adb', ['devices']);
+		const devices = adb.ok ? adb.out.split('\n').slice(1).filter((l) => l.includes('\tdevice')).length : 0;
+		row('adb', adb.ok, `${devices} device(s)`, 'Android SDK platform-tools on PATH');
+		row('ANDROID_HOME', !!process.env.ANDROID_HOME, process.env.ANDROID_HOME || 'unset',
+			'export ANDROID_HOME=$HOME/Library/Android/sdk');
+		row('JAVA_HOME', !!process.env.JAVA_HOME, process.env.JAVA_HOME || 'unset',
+			'JDK 17 (JDK 25 breaks the Android toolchain)');
+
+		let bad = 0;
+		for (const r of rows) {
+			if (r.ok) p.log.success(`${r.name} — ${r.detail || 'ok'}`);
+			else { bad++; p.log.warn(`${r.name} — missing${r.hint ? ` (${r.hint})` : ''}`); }
+		}
+		p.outro(bad === 0 ? 'All checks pass' : `${bad} missing — web still works, native targets need the above`);
+	},
+});

package/src/commands/typecheck.mjs

@@ -0,0 +1,23 @@
+import { command } from '@alloc/cmd-ts';
+import { existsSync } from 'node:fs';
+import * as p from '@clack/prompts';
+import { runTagged } from '../procs.mjs';
+
+export const typecheck = command({
+	name: 'typecheck',
+	description: 'tsrx-tsc --noEmit for every tsconfig present',
+	args: {},
+	handler: async () => {
+		const cwd = process.cwd();
+		const configs = ['tsconfig.json', 'tsconfig.native.json'].filter((f) => existsSync(`${cwd}/${f}`));
+		for (const c of configs) {
+			try {
+				await runTagged('tsc', 'pnpm', ['exec', 'tsrx-tsc', '--noEmit', '-p', c], cwd);
+			} catch (e) {
+				p.log.error(String(e));
+				process.exit(1);
+			}
+		}
+		p.log.success('Typecheck clean');
+	},
+});

package/src/procs.mjs

@@ -0,0 +1,33 @@
+// Prefixed process plumbing — dev runs several tools side by side, so each
+// gets a short tag on its output lines. SIGINT fans out to every child.
+import { spawn } from 'node:child_process';
+
+const children = new Set();
+
+process.on('SIGINT', () => {
+	for (const p of children) p.kill('SIGINT');
+	process.exit(130);
+});
+
+/** Spawn long-running, output prefixed `[tag]`. */
+export function spawnTagged(tag, cmd, args, cwd) {
+	const p = spawn(cmd, args, { cwd, env: process.env });
+	children.add(p);
+	const prefix = (chunk) => {
+		for (const line of chunk.toString().split('\n')) {
+			if (line.trim()) process.stdout.write(`[${tag}] ${line}\n`);
+		}
+	};
+	p.stdout.on('data', prefix);
+	p.stderr.on('data', prefix);
+	p.on('exit', () => children.delete(p));
+	return p;
+}
+
+/** Spawn to completion, output prefixed `[tag]`. Resolves on exit 0. */
+export function runTagged(tag, cmd, args, cwd) {
+	return new Promise((resolve, reject) => {
+		const p = spawnTagged(tag, cmd, args, cwd);
+		p.on('exit', (code) => (code === 0 ? resolve() : reject(new Error(`${tag} exited ${code}`))));
+	});
+}

package/src/targets.mjs

@@ -0,0 +1,78 @@
+// Target + device discovery. Everything degrades quietly — a missing
+// toolchain means the target is absent from prompts, not an error.
+import { existsSync } from 'node:fs';
+import { execFileSync } from 'node:child_process';
+
+const run = (cmd, args) => {
+	try {
+		return execFileSync(cmd, args, { encoding: 'utf8', timeout: 15000, stdio: ['ignore', 'pipe', 'ignore'] });
+	} catch {
+		return null;
+	}
+};
+
+export const hasWeb = (cwd) => existsSync(`${cwd}/vite.config.ts`) || existsSync(`${cwd}/vite.config.mts`);
+export const hasNative = (cwd) => existsSync(`${cwd}/nativescript.config.ts`);
+
+/** iOS targets: booted sims first, then other available sims, then physical devices. */
+export function iosTargets() {
+	const out = run('xcrun', ['simctl', 'list', 'devices', 'available', '-j']);
+	if (!out) return [];
+	try {
+		const j = JSON.parse(out);
+		const sims = [];
+		for (const list of Object.values(j.devices ?? {})) {
+			for (const d of list) {
+				if (!d.isAvailable) continue;
+				sims.push({
+					kind: 'ios',
+					id: d.udid,
+					name: d.name + (d.state === 'Booted' ? ' (booted)' : ''),
+					device: d.udid,
+					booted: d.state === 'Booted',
+				});
+			}
+		}
+		// Booted first — that's almost always the one you mean.
+		return sims.sort((a, b) => (b.booted ? 1 : 0) - (a.booted ? 1 : 0));
+	} catch {
+		return [];
+	}
+}
+
+/** Android targets: emulators + physical devices from adb. */
+export function androidTargets() {
+	const out = run('adb', ['devices']);
+	if (!out) return [];
+	return out
+		.split('\n')
+		.slice(1)
+		.map((l) => l.trim())
+		.filter((l) => l.endsWith('\tdevice'))
+		.map((l) => {
+			const serial = l.split('\t')[0];
+			const emu = serial.startsWith('emulator-');
+			return { kind: 'android', id: serial, name: emu ? `${serial} (emulator)` : `${serial} (device)`, device: serial };
+		});
+}
+
+/** Every launchable target for this project + machine. */
+export function discoverTargets(cwd) {
+	const targets = [];
+	if (hasWeb(cwd)) targets.push({ kind: 'web', id: 'web', name: 'Web (vite :5200)' });
+	if (hasNative(cwd)) {
+		targets.push(...iosTargets(), ...androidTargets());
+	}
+	return targets;
+}
+
+/** Distinct platform buckets for `build` — one entry per platform, no device picks. */
+export function buildTargets(cwd) {
+	const t = [];
+	if (hasWeb(cwd)) t.push({ kind: 'web', id: 'web', name: 'Web (vite build)' });
+	if (hasNative(cwd)) {
+		if (iosTargets().length || run('xcrun', ['--version'])) t.push({ kind: 'ios', id: 'ios', name: 'iOS (ns build ios)' });
+		t.push({ kind: 'android', id: 'android', name: 'Android (ns build android)' });
+	}
+	return t;
+}