gui4cli 0.0.0 → 0.0.2

package/dist/run/argv.js

@@ -0,0 +1,59 @@
+export function valuesFromDefaults(fields) {
+    const values = {};
+    for (const field of fields) {
+        if (field.default !== undefined) {
+            values[field.name] = coerce(field, field.default);
+        }
+        else if (field.type === "boolean") {
+            values[field.name] = false;
+        }
+        else {
+            values[field.name] = "";
+        }
+    }
+    return values;
+}
+export function buildArgv(fields, values) {
+    const argv = [];
+    for (const field of fields) {
+        const value = values[field.name];
+        if (field.positional) {
+            if (value !== undefined && value !== "" && value !== false) {
+                argv.push(String(value));
+            }
+            continue;
+        }
+        if (field.type === "boolean") {
+            if (value === true)
+                argv.push(field.longFlag);
+            continue;
+        }
+        if (value === undefined || value === "")
+            continue;
+        argv.push(field.longFlag, String(value));
+    }
+    return argv;
+}
+export function previewCommand(nodePath, target, argv, cwd) {
+    const quoted = [nodePath, target, ...argv].map(quote).join(" ");
+    return `${quoted}\n(in ${cwd})`;
+}
+export function missingRequired(fields, values) {
+    return fields
+        .filter((field) => field.required && field.type !== "boolean")
+        .filter((field) => {
+        const value = values[field.name];
+        return value === undefined || value === "";
+    })
+        .map((field) => field.label);
+}
+function coerce(field, value) {
+    if (field.type === "number")
+        return typeof value === "number" ? value : Number(value);
+    if (field.type === "boolean")
+        return Boolean(value);
+    return String(value);
+}
+function quote(part) {
+    return /[\s"]/.test(part) ? `"${part.replaceAll('"', '\\"')}"` : part;
+}

package/dist/run/kill.d.ts

@@ -0,0 +1 @@
+export declare function killProcessTree(pid: number): void;

package/dist/run/kill.js

@@ -0,0 +1,18 @@
+import { spawn } from "node:child_process";
+export function killProcessTree(pid) {
+    if (process.platform === "win32") {
+        spawn("taskkill", ["/pid", String(pid), "/T", "/F"], { stdio: "ignore", windowsHide: true });
+        return;
+    }
+    try {
+        process.kill(-pid, "SIGTERM");
+    }
+    catch {
+        try {
+            process.kill(pid, "SIGTERM");
+        }
+        catch {
+            // Already gone.
+        }
+    }
+}

package/dist/schema/form.d.ts

@@ -0,0 +1,139 @@
+import { z } from "zod";
+export declare const fieldTypeSchema: z.ZodEnum<["string", "number", "boolean", "choice", "file", "directory"]>;
+export type FieldType = z.infer<typeof fieldTypeSchema>;
+export declare const fieldSchema: z.ZodObject<{
+    name: z.ZodString;
+    longFlag: z.ZodString;
+    shortFlag: z.ZodOptional<z.ZodString>;
+    type: z.ZodEnum<["string", "number", "boolean", "choice", "file", "directory"]>;
+    label: z.ZodString;
+    help: z.ZodOptional<z.ZodString>;
+    required: z.ZodBoolean;
+    default: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+    choices: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    positional: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    type: "string" | "number" | "boolean" | "choice" | "file" | "directory";
+    name: string;
+    longFlag: string;
+    label: string;
+    required: boolean;
+    shortFlag?: string | undefined;
+    help?: string | undefined;
+    default?: string | number | boolean | undefined;
+    choices?: string[] | undefined;
+    positional?: boolean | undefined;
+}, {
+    type: "string" | "number" | "boolean" | "choice" | "file" | "directory";
+    name: string;
+    longFlag: string;
+    label: string;
+    required: boolean;
+    shortFlag?: string | undefined;
+    help?: string | undefined;
+    default?: string | number | boolean | undefined;
+    choices?: string[] | undefined;
+    positional?: boolean | undefined;
+}>;
+export type Field = z.infer<typeof fieldSchema>;
+export declare const detectSourceSchema: z.ZodEnum<["commander", "yargs", "jsdoc", "config", "help", "merged"]>;
+export type DetectSource = z.infer<typeof detectSourceSchema>;
+export declare const formSpecSchema: z.ZodObject<{
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    target: z.ZodString;
+    cwd: z.ZodString;
+    source: z.ZodEnum<["commander", "yargs", "jsdoc", "config", "help", "merged"]>;
+    fields: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        longFlag: z.ZodString;
+        shortFlag: z.ZodOptional<z.ZodString>;
+        type: z.ZodEnum<["string", "number", "boolean", "choice", "file", "directory"]>;
+        label: z.ZodString;
+        help: z.ZodOptional<z.ZodString>;
+        required: z.ZodBoolean;
+        default: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+        choices: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        positional: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        type: "string" | "number" | "boolean" | "choice" | "file" | "directory";
+        name: string;
+        longFlag: string;
+        label: string;
+        required: boolean;
+        shortFlag?: string | undefined;
+        help?: string | undefined;
+        default?: string | number | boolean | undefined;
+        choices?: string[] | undefined;
+        positional?: boolean | undefined;
+    }, {
+        type: "string" | "number" | "boolean" | "choice" | "file" | "directory";
+        name: string;
+        longFlag: string;
+        label: string;
+        required: boolean;
+        shortFlag?: string | undefined;
+        help?: string | undefined;
+        default?: string | number | boolean | undefined;
+        choices?: string[] | undefined;
+        positional?: boolean | undefined;
+    }>, "many">;
+    window: z.ZodOptional<z.ZodObject<{
+        width: z.ZodOptional<z.ZodNumber>;
+        height: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        width?: number | undefined;
+        height?: number | undefined;
+    }, {
+        width?: number | undefined;
+        height?: number | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    title: string;
+    target: string;
+    cwd: string;
+    source: "help" | "commander" | "yargs" | "jsdoc" | "config" | "merged";
+    fields: {
+        type: "string" | "number" | "boolean" | "choice" | "file" | "directory";
+        name: string;
+        longFlag: string;
+        label: string;
+        required: boolean;
+        shortFlag?: string | undefined;
+        help?: string | undefined;
+        default?: string | number | boolean | undefined;
+        choices?: string[] | undefined;
+        positional?: boolean | undefined;
+    }[];
+    description?: string | undefined;
+    window?: {
+        width?: number | undefined;
+        height?: number | undefined;
+    } | undefined;
+}, {
+    title: string;
+    target: string;
+    cwd: string;
+    source: "help" | "commander" | "yargs" | "jsdoc" | "config" | "merged";
+    fields: {
+        type: "string" | "number" | "boolean" | "choice" | "file" | "directory";
+        name: string;
+        longFlag: string;
+        label: string;
+        required: boolean;
+        shortFlag?: string | undefined;
+        help?: string | undefined;
+        default?: string | number | boolean | undefined;
+        choices?: string[] | undefined;
+        positional?: boolean | undefined;
+    }[];
+    description?: string | undefined;
+    window?: {
+        width?: number | undefined;
+        height?: number | undefined;
+    } | undefined;
+}>;
+export type FormSpec = z.infer<typeof formSpecSchema>;
+export declare const formValuesSchema: z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+export type FormValues = z.infer<typeof formValuesSchema>;
+export declare function labelFromName(name: string): string;

package/dist/schema/form.js

@@ -0,0 +1,51 @@
+import { z } from "zod";
+export const fieldTypeSchema = z.enum([
+    "string",
+    "number",
+    "boolean",
+    "choice",
+    "file",
+    "directory",
+]);
+export const fieldSchema = z.object({
+    name: z.string().min(1),
+    longFlag: z.string().min(1),
+    shortFlag: z.string().optional(),
+    type: fieldTypeSchema,
+    label: z.string().min(1),
+    help: z.string().optional(),
+    required: z.boolean(),
+    default: z.union([z.string(), z.number(), z.boolean()]).optional(),
+    choices: z.array(z.string()).optional(),
+    positional: z.boolean().optional(),
+});
+export const detectSourceSchema = z.enum([
+    "commander",
+    "yargs",
+    "jsdoc",
+    "config",
+    "help",
+    "merged",
+]);
+export const formSpecSchema = z.object({
+    title: z.string().min(1),
+    description: z.string().optional(),
+    target: z.string().min(1),
+    cwd: z.string().min(1),
+    source: detectSourceSchema,
+    fields: z.array(fieldSchema),
+    window: z
+        .object({
+        width: z.number().int().positive().optional(),
+        height: z.number().int().positive().optional(),
+    })
+        .optional(),
+});
+export const formValuesSchema = z.record(z.string(), z.union([z.string(), z.number(), z.boolean()]));
+export function labelFromName(name) {
+    return name
+        .replace(/^--?/, "")
+        .replace(/[-_]/g, " ")
+        .replace(/([a-z])([A-Z])/g, "$1 $2")
+        .replace(/\b\w/g, (ch) => ch.toUpperCase());
+}

package/dist/window/env.d.ts

@@ -0,0 +1 @@
+export declare function windowProcessEnv(source?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;

package/dist/window/env.js

@@ -0,0 +1,14 @@
+const INSPECTOR_KEYS = [
+    "VSCODE_INSPECTOR_OPTIONS",
+    "NODE_INSPECT_RESUME_ON_START",
+    "NODE_OPTIONS",
+    "NODE_DEBUG",
+    "NODE_UNIQUE_ID",
+];
+export function windowProcessEnv(source = process.env) {
+    const env = { ...source };
+    for (const key of INSPECTOR_KEYS) {
+        delete env[key];
+    }
+    return env;
+}

package/dist/window/open.d.ts

@@ -0,0 +1,2 @@
+import type { FormSpec } from "../schema/form.js";
+export declare function openWindow(dir: string, spec: FormSpec): Promise<number>;

package/dist/window/open.js

@@ -0,0 +1,44 @@
+import { spawn } from "node:child_process";
+import { Gui4CliError } from "../errors.js";
+import { windowProcessEnv } from "./env.js";
+import { resolveWindowdLaunch } from "./resolve.js";
+const QUICK_EXIT_MS = 5000;
+export async function openWindow(dir, spec) {
+    const first = await spawnWindowd(dir, spec);
+    if (first.elapsedMs < QUICK_EXIT_MS && first.code === 0) {
+        process.stderr.write("The window closed right away. Opening it again…\n");
+        return (await spawnWindowd(dir, spec)).code;
+    }
+    return first.code;
+}
+async function spawnWindowd(dir, spec) {
+    const launch = resolveWindowdLaunch();
+    const width = String(spec.window?.width ?? 960);
+    const height = String(spec.window?.height ?? 620);
+    const artifacts = process.env.GUI4CLI_WINDOW_LOGS;
+    const args = [
+        ...launch.prefixArgs,
+        launch.cli,
+        "--title",
+        spec.title,
+        "--width",
+        width,
+        "--height",
+        height,
+        ...(artifacts ? ["--artifacts", artifacts, "--debug"] : []),
+    ];
+    const started = Date.now();
+    return new Promise((resolve, reject) => {
+        const child = spawn(launch.command, args, {
+            cwd: dir,
+            stdio: "inherit",
+            env: windowProcessEnv(),
+        });
+        child.on("error", (error) => {
+            reject(new Gui4CliError("Could not open the desktop window.", `${error.message}\nwindowd is installed. If this keeps failing, install Bun from https://bun.sh and run pnpm dev again.`));
+        });
+        child.on("close", (code) => {
+            resolve({ code: code ?? 0, elapsedMs: Date.now() - started });
+        });
+    });
+}

package/dist/window/resolve.d.ts

@@ -0,0 +1,6 @@
+export type WindowdLaunch = {
+    command: string;
+    prefixArgs: string[];
+    cli: string;
+};
+export declare function resolveWindowdLaunch(): WindowdLaunch;

package/dist/window/resolve.js

@@ -0,0 +1,49 @@
+import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
+import { delimiter, dirname, join } from "node:path";
+import { Gui4CliError } from "../errors.js";
+const require = createRequire(import.meta.url);
+export function resolveWindowdLaunch() {
+    let windowdRoot;
+    try {
+        windowdRoot = dirname(require.resolve("windowd/package.json"));
+    }
+    catch {
+        throw new Gui4CliError("Could not find the windowd package.", "From this repo run: pnpm install");
+    }
+    const cli = join(windowdRoot, "bin", "cli.ts");
+    if (!existsSync(cli)) {
+        throw new Gui4CliError("windowd is installed but its launcher file is missing.", `Expected ${cli}`);
+    }
+    const bun = findOnPath("bun");
+    if (bun) {
+        return { command: bun, prefixArgs: [], cli };
+    }
+    const tsxCli = resolveTsxCli();
+    return { command: process.execPath, prefixArgs: [tsxCli], cli };
+}
+function resolveTsxCli() {
+    try {
+        const tsxRoot = dirname(require.resolve("tsx/package.json"));
+        const cli = join(tsxRoot, "dist", "cli.mjs");
+        if (existsSync(cli))
+            return cli;
+    }
+    catch {
+        // Fall through.
+    }
+    throw new Gui4CliError("Could not start the desktop window.", "windowd needs Bun (https://bun.sh) or tsx. From this repo run: pnpm install");
+}
+function findOnPath(name) {
+    const exts = process.platform === "win32" ? [".exe", ".cmd", ""] : [""];
+    for (const dir of (process.env.PATH ?? "").split(delimiter)) {
+        if (!dir)
+            continue;
+        for (const ext of exts) {
+            const candidate = join(dir, `${name}${ext}`);
+            if (existsSync(candidate))
+                return candidate;
+        }
+    }
+    return undefined;
+}

package/package.json

@@ -1,17 +1,27 @@
 {
   "name": "gui4cli",
-  "version": "0.0.0",
-  "description": "Turn a Node.js CLI script into a desktop form app — inputs, run button, live output. Placeholder release; the CLI is not ready yet.",
+  "version": "0.0.2",
+  "description": "Turn a Node.js CLI script into a desktop form app — inputs, run button, live output.",
   "type": "module",
   "bin": {
-    "gui4cli": "bin/argui.js",
-    "argui": "bin/argui.js"
+    "gui4cli": "bin/gui4cli.js",
+    "argui": "bin/gui4cli.js"
   },
   "files": [
     "bin",
+    "dist",
     "README.md",
     "LICENSE"
   ],
+  "scripts": {
+    "dev": "tsx src/cli.ts fixtures/resize.js",
+    "detect": "tsx src/cli.ts fixtures/resize.js --json",
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "prepare": "tsc",
+    "prepublishOnly": "node scripts/publish-gate.mjs && pnpm test && pnpm build"
+  },
   "keywords": [
     "cli",
     "desktop",
@@ -24,5 +34,17 @@
   "author": "Catalyst Forge LLC",
   "engines": {
     "node": ">=20"
+  },
+  "dependencies": {
+    "windowd": "^0.7.0",
+    "zod": "^3.25.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "commander": "^14.0.0",
+    "tsx": "^4.20.0",
+    "typescript": "^5.9.0",
+    "vitest": "^3.2.0",
+    "yargs": "^18.0.0"
   }
 }

package/bin/argui.js

@@ -1,4 +0,0 @@
-#!/usr/bin/env node
-
-console.log("ArgUI is reserved but not ready yet.");
-process.exit(0);