symlx 0.1.2 → 0.1.3

package/dist/cli.js

@@ -35,38 +35,27 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 const commander_1 = require("commander");
-const serve_1 = require("./commands/serve");
 const log = __importStar(require("./ui/logger"));
-// Accepted values for --collision.
-const ALLOWED_COLLISIONS = new Set(["prompt", "skip", "fail", "overwrite"]);
-// Converts raw CLI input into a validated union type used by the serve command.
-function parseCollisionPolicy(value) {
-    if (!ALLOWED_COLLISIONS.has(value)) {
-        throw new Error(`invalid collision policy "${value}". expected: prompt|skip|fail|overwrite`);
-    }
-    return value;
+const serve_1 = require("./commands/serve");
+function collectBinEntry(value, previous = []) {
+    previous.push(value);
+    return previous;
 }
 async function main() {
     // Commander orchestrates top-level commands/options and help output.
     const program = new commander_1.Command();
     program
-        .name("symlx")
-        .description("Temporary CLI bin linker with lifecycle cleanup")
+        .name('symlx')
+        .description('Temporary CLI bin linker with lifecycle cleanup')
         .showHelpAfterError();
     program
-        .command("serve")
+        .command('serve')
         .description("Link this project's package.json bins until symlx exits")
-        .option("--bin-dir <dir>", "target bin directory (default: ~/.symlx/bin)")
-        .option("--collision <policy>", "collision mode: prompt|skip|fail|overwrite", "prompt")
-        .option("--non-interactive", "disable interactive prompts", false)
-        .action(async (options) => {
-        // Delegate all runtime behavior to the command module.
-        await (0, serve_1.runServe)({
-            binDir: options.binDir,
-            collision: parseCollisionPolicy(options.collision),
-            nonInteractive: options.nonInteractive
-        });
-    });
+        .option('--bin-dir <dir>', 'target bin directory (default: ~/.symlx/bin)')
+        .option('--collision <policy>', 'collision mode: prompt|skip|fail|overwrite', 'prompt')
+        .option('--non-interactive', 'disable interactive prompts', false)
+        .option('--bin <name=path>', 'custom bin mapping (repeatable), e.g. --bin my-cli=./cli.js', collectBinEntry, [])
+        .action(serve_1.serveCommand);
     await program.parseAsync(process.argv);
 }
 // Centralized fatal error boundary for command execution.

package/dist/commands/serve.js

@@ -33,14 +33,17 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.runServe = runServe;
-const paths_1 = require("../core/paths");
+exports.serveCommand = serveCommand;
+const paths_1 = require("../lib/paths");
 const link_manager_1 = require("../services/link-manager");
 const lifecycle_1 = require("../services/lifecycle");
+// @ts-ignore
 const package_bins_1 = require("../services/package-bins");
 const session_store_1 = require("../services/session-store");
 const collision_prompt_1 = require("../ui/collision-prompt");
 const log = __importStar(require("../ui/logger"));
+const options_1 = require("../lib/options");
+const schema_1 = require("../lib/schema");
 // Prompts require an interactive terminal; scripts/CI should avoid prompt mode.
 function isInteractiveSession() {
     return Boolean(process.stdin.isTTY && process.stdout.isTTY);
@@ -50,7 +53,7 @@ function isInteractiveSession() {
 // 2) create links
 // 3) persist session
 // 4) keep process alive and cleanup on exit
-async function runServe(options) {
+async function run(options) {
     const cwd = process.cwd();
     const paths = (0, paths_1.getSymlxPaths)(options.binDir);
     // Prepare runtime directories and recover stale sessions from previous abnormal exits.
@@ -103,3 +106,7 @@ async function runServe(options) {
         setInterval(() => undefined, 60_000);
     });
 }
+function serveCommand(inlineOptions) {
+    const options = (0, options_1.resolveOptions)(schema_1.serveInlineOptionsSchema, inlineOptions);
+    return run(options);
+}

package/dist/lib/options.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveOptions = resolveOptions;
+const path_1 = __importDefault(require("path"));
+const node_os_1 = __importDefault(require("node:os"));
+const utils_1 = require("./utils");
+const validate_1 = require("./validate");
+const package_bins_1 = require("../services/package-bins");
+const defaultOptions = {
+    collision: 'prompt',
+    nonInteractive: false,
+    binDir: path_1.default.join(node_os_1.default.homedir(), '.symlx', 'bin'),
+    bin: {},
+};
+// Function to aggregate all options from different sources in order or priority
+function resolveOptions(inlineOptionsSchema, inlineOptions) {
+    // Load the bin from package.json
+    const packageJSONOptions = (0, package_bins_1.loadPackageJSONOptions)(process.cwd());
+    // Load and validate the options from the config file,
+    // silently overriding invalid non-critical values with defaults or inline based on order of priority
+    const configFileOptions = (0, utils_1.loadConfigFileOptions)();
+    const validatedConfigFileOptions = (0, validate_1.validateConfigFileOptions)(configFileOptions);
+    // Validate the CLI inline options if available
+    const validatedInlineOptions = (0, validate_1.validateInlineOptions)(inlineOptionsSchema, inlineOptions);
+    // Default options first
+    // -> Config file options override defaults
+    // -> CLI inline options overrides config file options
+    const finalOptiions = {
+        ...defaultOptions,
+        ...(validatedConfigFileOptions ?? {}),
+        ...(validatedInlineOptions ?? {}),
+    };
+    if (!Object.entries(finalOptiions.bin).length) {
+        throw new Error([
+            'no bin entries found. add at least one bin in any of these places:',
+            '1) package.json -> "bin": { "my-cli": "./cli.js" }',
+            '2) symlx.config.json -> "bin": { "my-cli": "./cli.js" }',
+            '3) inline CLI -> symlx serve --bin my-cli=./cli.js',
+            '4) if package.json "bin" is a string, set a valid package.json "name" (used to infer the bin name).',
+        ].join('\n'));
+    }
+    return finalOptiions;
+}

package/dist/lib/paths.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSymlxPaths = getSymlxPaths;
+exports.pathContainsDir = pathContainsDir;
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+function getSymlxPaths(binDir) {
+    // Keep mutable runtime state under the user's home directory.
+    // Session files live separately from bins and are used for stale cleanup.
+    const sessionDir = node_path_1.default.join(node_os_1.default.homedir(), '.symlx', 'sessions');
+    return { binDir, sessionDir };
+}
+// Checks if PATH already contains a directory so we can avoid noisy setup hints.
+function pathContainsDir(currentPath, targetDir) {
+    if (!currentPath) {
+        return false;
+    }
+    const resolvedTarget = node_path_1.default.resolve(targetDir);
+    const parts = currentPath
+        .split(node_path_1.default.delimiter)
+        .map((item) => node_path_1.default.resolve(item));
+    return parts.includes(resolvedTarget);
+}

package/dist/lib/schema.js

@@ -0,0 +1,84 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serveInlineOptionsSchema = exports.configFileOptionsSchema = exports.binEntriesToRecordSchema = void 0;
+const zod_1 = require("zod");
+const log = __importStar(require("../ui/logger"));
+const binNameSchema = zod_1.z
+    .string()
+    .regex(/^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/, 'invalid bin name');
+const binTargetSchema = zod_1.z
+    .string()
+    .trim()
+    .min(1)
+    .regex(/^\.{1,2}\//, 'bin target must be a relative path like ./cli.js');
+const customBinSchema = zod_1.z.record(binNameSchema, binTargetSchema);
+const configFileOptionsSchema = zod_1.z.object({
+    binDir: zod_1.z
+        .string()
+        .regex(/(^|[\\/])\.[^\\/]+([\\/]|$)/, 'binDir must include a dotted folder segment')
+        .optional(),
+    collision: zod_1.z
+        .enum(['prompt', 'skip', 'fail', 'overwrite'])
+        .optional()
+        .catch(() => {
+        log.warn('invalid "collision" value in config file; using default.');
+        return undefined;
+    }),
+    nonInteractive: zod_1.z
+        .boolean()
+        .optional()
+        .catch(() => {
+        log.warn('invalid "nonInteractive" value in config file; using default.');
+        return undefined;
+    }),
+    bin: customBinSchema.optional(),
+});
+exports.configFileOptionsSchema = configFileOptionsSchema;
+const binEntrySchema = zod_1.z
+    .string()
+    .regex(/^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?=\.{1,2}\/.+$/, 'expected <name=./relative/path>');
+exports.binEntriesToRecordSchema = zod_1.z
+    .array(binEntrySchema)
+    .optional()
+    .default([])
+    .transform((entries) => Object.fromEntries(entries.map((entry) => {
+    const [name, target] = entry.split('=', 2);
+    return [name, target];
+})));
+const serveInlineOptionsSchema = configFileOptionsSchema.extend({
+    bin: exports.binEntriesToRecordSchema,
+});
+exports.serveInlineOptionsSchema = serveInlineOptionsSchema;

package/dist/lib/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/utils.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadJSONFile = loadJSONFile;
+exports.loadConfigFileOptions = loadConfigFileOptions;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+// Invalid/corrupted JSON files are ignored.
+function loadJSONFile(filePath) {
+    try {
+        const raw = node_fs_1.default.readFileSync(filePath, 'utf8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return undefined;
+    }
+}
+function loadConfigFileOptions() {
+    const cwd = process.cwd();
+    const configPath = node_path_1.default.join(cwd, 'symlx.config.json');
+    const configFileOptions = loadJSONFile(configPath);
+    return configFileOptions;
+}

package/dist/lib/validate.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateInlineOptions = validateInlineOptions;
+exports.validateConfigFileOptions = validateConfigFileOptions;
+const schema_1 = require("./schema");
+function formatIssues(error) {
+    const details = error.issues
+        .map((issue) => {
+        const pathLabel = issue.path.length > 0 ? issue.path.join('.') : 'value';
+        return `${pathLabel}: ${issue.message}`;
+    })
+        .join('; ');
+    return details || 'invalid input';
+}
+function validateInlineOptions(schema, input, label = 'input') {
+    const result = schema.safeParse(input || {});
+    if (!result.success) {
+        throw new Error(`invalid ${label}: ${formatIssues(result.error)}`);
+    }
+    return result.data;
+}
+function validateConfigFileOptions(input, label = 'input') {
+    const result = schema_1.configFileOptionsSchema.safeParse(input || {});
+    if (!result.success) {
+        throw new Error(`invalid ${label}: ${formatIssues(result.error)}`);
+    }
+    return result.data;
+}

package/dist/lib/validators.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serveOptionsSchema = exports.collisionPolicySchema = void 0;
+exports.validate = validate;
+const zod_1 = require("zod");
+const collisionPolicySchema = zod_1.z.enum(['prompt', 'skip', 'fail', 'overwrite']);
+exports.collisionPolicySchema = collisionPolicySchema;
+const serveOptionsSchema = zod_1.z.object({
+    binDir: zod_1.z.string().trim().min(1).optional(),
+    collision: collisionPolicySchema,
+    nonInteractive: zod_1.z.boolean(),
+});
+exports.serveOptionsSchema = serveOptionsSchema;
+function formatIssues(error) {
+    const details = error.issues
+        .map((issue) => {
+        const pathLabel = issue.path.length > 0 ? issue.path.join('.') : 'value';
+        return `${pathLabel}: ${issue.message}`;
+    })
+        .join('; ');
+    return details || 'invalid input';
+}
+function validate(schema, input, label = 'input') {
+    const result = schema.safeParse(input);
+    if (!result.success) {
+        throw new Error(`invalid ${label}: ${formatIssues(result.error)}`);
+    }
+    return result.data;
+}

package/dist/services/link-manager.js

@@ -13,7 +13,7 @@ function tryLstat(filePath) {
     }
     catch (error) {
         const code = error.code;
-        if (code === "ENOENT") {
+        if (code === 'ENOENT') {
             return undefined;
         }
         throw error;
@@ -54,17 +54,17 @@ function toConflict(name, linkPath, target, node) {
             target,
             reason: node.existingTarget
                 ? `already linked to ${node.existingTarget}`
-                : "already exists as symlink",
+                : 'already exists as symlink',
             existingTarget: node.existingTarget,
-            isSymlink: true
+            isSymlink: true,
         };
     }
     return {
         name,
         linkPath,
         target,
-        reason: "already exists as a file",
-        isSymlink: false
+        reason: 'already exists as a file',
+        isSymlink: false,
     };
 }
 // Creates symlinks for all project bins according to the selected collision strategy.
@@ -79,27 +79,34 @@ async function createLinks(params) {
         if (existingNode) {
             const conflict = toConflict(name, linkPath, target, existingNode);
             // Reusing the exact same link is always a no-op.
-            if (conflict.existingTarget && node_path_1.default.resolve(conflict.existingTarget) === node_path_1.default.resolve(target)) {
-                skipped.push({ name, linkPath, reason: "already linked to requested target" });
+            if (conflict.existingTarget &&
+                node_path_1.default.resolve(conflict.existingTarget) === node_path_1.default.resolve(target)) {
+                skipped.push({
+                    name,
+                    linkPath,
+                    reason: 'already linked to requested target',
+                });
                 continue;
             }
             let decision;
-            if (policy === "skip") {
-                decision = "skip";
+            if (policy === 'skip') {
+                decision = 'skip';
             }
-            else if (policy === "overwrite") {
-                decision = "overwrite";
+            else if (policy === 'overwrite') {
+                decision = 'overwrite';
             }
-            else if (policy === "fail") {
+            else if (policy === 'fail') {
                 throw new Error(`command "${name}" conflicts at ${linkPath}: ${conflict.reason}`);
             }
             else {
-                decision = collisionResolver ? await collisionResolver(conflict) : "skip";
+                decision = collisionResolver
+                    ? await collisionResolver(conflict)
+                    : 'skip';
             }
-            if (decision === "abort") {
+            if (decision === 'abort') {
                 throw new Error(`aborted on collision for command "${name}"`);
             }
-            if (decision === "skip") {
+            if (decision === 'skip') {
                 skipped.push({ name, linkPath, reason: conflict.reason });
                 continue;
             }

package/dist/services/package-bins.js

@@ -3,56 +3,60 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.readBins = readBins;
+exports.loadPackageJSONOptions = loadPackageJSONOptions;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
+const utils_1 = require("../lib/utils");
 // npm allows `bin` as a string; in that form the command name defaults to package name
 // (without scope for scoped packages).
 function inferBinName(packageName) {
     if (!packageName) {
-        throw new Error("package.json is missing `name`, needed when `bin` is a string");
+        return undefined;
     }
-    if (packageName.startsWith("@")) {
-        const parts = packageName.split("/");
+    if (packageName.startsWith('@')) {
+        const parts = packageName.split('/');
         if (parts.length !== 2 || !parts[1]) {
-            throw new Error(`invalid package name: ${packageName}`);
+            return undefined;
         }
         return parts[1];
     }
     return packageName;
 }
-function readJsonFile(filePath) {
-    const raw = node_fs_1.default.readFileSync(filePath, "utf8");
-    return JSON.parse(raw);
-}
 // Loads and validates all bin entries for the current project.
 // Returned map is command name => absolute target file path.
-function readBins(cwd) {
-    const packageJsonPath = node_path_1.default.join(cwd, "package.json");
+function loadPackageJSONOptions(cwd) {
+    const packageJsonPath = node_path_1.default.join(cwd, 'package.json');
     if (!node_fs_1.default.existsSync(packageJsonPath)) {
-        throw new Error(`missing package.json in ${cwd}`);
-    }
-    const packageJson = readJsonFile(packageJsonPath);
-    if (!packageJson.bin) {
-        throw new Error("package.json has no `bin` field");
-    }
-    const bins = new Map();
-    if (typeof packageJson.bin === "string") {
-        bins.set(inferBinName(packageJson.name), node_path_1.default.resolve(cwd, packageJson.bin));
+        return {
+            bin: {},
+        };
+    }
+    const packageJson = (0, utils_1.loadJSONFile)(packageJsonPath);
+    if (!packageJson || !packageJson.bin) {
+        return {
+            bin: {},
+        };
+    }
+    const bins = {};
+    if (typeof packageJson.bin === 'string') {
+        const inferredBinName = inferBinName(packageJson.name);
+        if (inferredBinName) {
+            bins[inferredBinName] = node_path_1.default.resolve(cwd, packageJson.bin);
+        }
     }
     else {
         for (const [name, relTarget] of Object.entries(packageJson.bin)) {
-            bins.set(name, node_path_1.default.resolve(cwd, relTarget));
-        }
-    }
-    if (bins.size === 0) {
-        throw new Error("no bin entries found");
-    }
-    // Fail fast if package.json points to non-existing executables.
-    for (const [name, target] of bins.entries()) {
-        if (!node_fs_1.default.existsSync(target)) {
-            throw new Error(`bin target for "${name}" does not exist: ${target}`);
+            bins[name] = node_path_1.default.resolve(cwd, relTarget);
         }
     }
-    return bins;
+    // if (bins.size === 0) {
+    //   throw new Error('no bin entries found');
+    // }
+    // // Fail fast if package.json points to non-existing executables.
+    // for (const [name, target] of bins.entries()) {
+    //   if (!fs.existsSync(target)) {
+    //     throw new Error(`bin target for "${name}" does not exist: ${target}`);
+    //   }
+    // }
+    return { bin: {} };
 }

package/dist/services/session-store.js

@@ -1,4 +1,37 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -10,6 +43,8 @@ exports.createSessionFilePath = createSessionFilePath;
 exports.cleanupSession = cleanupSession;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
+const log = __importStar(require("../ui/logger"));
+const utils_1 = require("../lib/utils");
 // Checks whether a PID from a previous session is still alive.
 function isProcessAlive(pid) {
     // PIDs are always positive integer typically less the 2^15
@@ -37,16 +72,6 @@ function deleteFile(filePath) {
         // Best-effort cleanup.
     }
 }
-// Invalid/corrupted session files are ignored and later removed.
-function loadSessionFileJSON(filePath) {
-    try {
-        const raw = node_fs_1.default.readFileSync(filePath, 'utf8');
-        return JSON.parse(raw);
-    }
-    catch {
-        return undefined;
-    }
-}
 // Removes only symlinks that still point to the exact targets we created.
 // This avoids deleting user-managed commands with the same name.
 function cleanupLinks(links) {
@@ -79,6 +104,7 @@ function cleanupStaleSessions(sessionDir) {
     if (!node_fs_1.default.existsSync(sessionDir)) {
         return;
     }
+    let cleanUpCount = 0;
     // Loop through the files within the session
     for (const entry of node_fs_1.default.readdirSync(sessionDir)) {
         const filePath = node_path_1.default.join(sessionDir, entry);
@@ -88,16 +114,21 @@ function cleanupStaleSessions(sessionDir) {
             continue;
         }
         // If the expected file structure has been corrupted, delete the file
-        const record = loadSessionFileJSON(filePath);
+        const record = (0, utils_1.loadJSONFile)(filePath);
         if (!record) {
             deleteFile(filePath);
             continue;
         }
+        // If process is dead, unlink the command from the bin and delete the session file
         if (!isProcessAlive(record.pid)) {
             cleanupLinks(record.links);
             deleteFile(filePath);
+            cleanUpCount++;
         }
     }
+    if (cleanUpCount > 0) {
+        log.info(`cleaned up ${cleanUpCount} expired session${cleanUpCount > 1 ? 's' : ''}`);
+    }
 }
 // Persists currently linked commands so future runs can clean stale state.
 function persistSession(sessionPath, record) {

package/dist/ui/collision-prompt.js

@@ -9,32 +9,32 @@ const prompts_1 = __importDefault(require("prompts"));
 // Returning "abort" bubbles up as an error to stop the current serve run.
 async function promptCollisionDecision(conflict) {
     const response = await (0, prompts_1.default)({
-        type: "select",
-        name: "decision",
+        type: 'select',
+        name: 'decision',
         message: `command "${conflict.name}" already exists`,
         choices: [
             {
-                title: "Overwrite existing command",
-                value: "overwrite",
-                description: `Replace ${conflict.linkPath}`
+                title: 'Overwrite existing command',
+                value: 'overwrite',
+                description: `Replace ${conflict.linkPath}`,
             },
             {
-                title: "Skip this command",
-                value: "skip",
-                description: conflict.reason
+                title: 'Skip this command',
+                value: 'skip',
+                description: conflict.reason,
             },
             {
-                title: "Abort",
-                value: "abort",
-                description: "Stop serve without linking remaining commands"
-            }
+                title: 'Abort',
+                value: 'abort',
+                description: 'Stop serve without linking remaining commands',
+            },
         ],
-        initial: 1
+        initial: 1,
     }, {
-        onCancel: () => false
+        onCancel: () => false,
     });
     if (!response.decision) {
-        return "abort";
+        return 'abort';
     }
     return response.decision;
 }

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "symlx",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Temporary local CLI bin linker",
   "license": "MIT",
   "bin": {
-    "symlx": "dist/cli.js",
-    "cx": "dist/cli.js"
+    "symlx": "dist/clii.js",
+    "cx": "dist/clii.js"
   },
   "files": [
     "dist",
@@ -26,7 +26,8 @@
   },
   "dependencies": {
     "commander": "^12.1.0",
-    "prompts": "^2.4.2"
+    "prompts": "^2.4.2",
+    "zod": "^4.3.6"
   },
   "scripts": {
     "build": "tsc -p tsconfig.json && chmod +x dist/cli.js",