symlx 0.1.2 → 0.1.4

package/dist/lib/options.js

@@ -0,0 +1,92 @@
+"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 validator_1 = require("./validator");
+const DEFAULT_OPTIONS = {
+    collision: 'prompt',
+    nonInteractive: false,
+    binDir: path_1.default.join(node_os_1.default.homedir(), '.symlx', 'bin'),
+    bin: {},
+    binResolutionStrategy: 'replace',
+};
+function hasBinEntries(bin) {
+    return Boolean(bin && Object.keys(bin).length > 0);
+}
+function computeResolvedBin(inlineBin, configFileBin, packageJSONBin, binResolutionStrategy) {
+    // Aggregates bin from all sources:
+    // inline + config + package.json + default
+    if (binResolutionStrategy === 'merge') {
+        return {
+            ...(packageJSONBin ?? {}),
+            ...(configFileBin ?? {}),
+            ...(inlineBin ?? {}),
+        };
+    }
+    // Bin source precedence is value-aware:
+    // inline (if non-empty) -> config (if non-empty) -> package.json (if non-empty) -> default.
+    return hasBinEntries(inlineBin)
+        ? inlineBin
+        : hasBinEntries(configFileBin)
+            ? configFileBin
+            : hasBinEntries(packageJSONBin)
+                ? packageJSONBin
+                : DEFAULT_OPTIONS.bin;
+}
+function withCwdPrefixedBin(cwd, bin) {
+    return Object.fromEntries(Object.entries(bin).map(([name, target]) => [
+        name,
+        path_1.default.resolve(cwd, target),
+    ]));
+}
+// Function to aggregate all options from different sources in order or priority
+function resolveOptions(cwd, inlineOptionsSchema, inlineOptions) {
+    const packageJSONLoadResult = (0, utils_1.loadPackageJSONOptions)(cwd);
+    const validatedPackageJSONOptions = (0, validator_1.validatePackageJSONOptions)(packageJSONLoadResult);
+    const packageJSONIssues = [
+        ...packageJSONLoadResult.issues,
+        ...validatedPackageJSONOptions.issues,
+    ];
+    const fatalPackageIssue = packageJSONIssues.find((issue) => issue.startsWith('invalid package.json'));
+    if (fatalPackageIssue) {
+        throw new Error(fatalPackageIssue);
+    }
+    const configFileLoadResult = (0, utils_1.loadConfigFileOptions)(cwd);
+    if (configFileLoadResult.issue) {
+        throw new Error(configFileLoadResult.issue);
+    }
+    const validatedConfigFileOptions = (0, validator_1.validateConfigFileOptions)(configFileLoadResult.options);
+    const validatedInlineOptions = (0, validator_1.validateInlineOptions)(inlineOptionsSchema, inlineOptions);
+    const inlineBin = validatedInlineOptions
+        .bin;
+    const mergedOptions = {
+        ...DEFAULT_OPTIONS,
+        ...(validatedPackageJSONOptions ?? {}),
+        ...(validatedConfigFileOptions ?? {}),
+        ...(validatedInlineOptions ?? {}),
+    };
+    const resolvedBin = computeResolvedBin(inlineBin, validatedConfigFileOptions.bin, validatedPackageJSONOptions.bin, mergedOptions.binResolutionStrategy);
+    const finalOptions = {
+        ...mergedOptions,
+        bin: withCwdPrefixedBin(cwd, resolvedBin),
+    };
+    if (Object.keys(finalOptions.bin).length > 0) {
+        return finalOptions;
+    }
+    const primaryIssue = packageJSONIssues[0];
+    if (primaryIssue) {
+        throw new Error(primaryIssue);
+    }
+    throw new Error([
+        'no bin entries found.',
+        'add at least one command in one 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',
+    ].join('\n'));
+}

package/dist/lib/schema.js

@@ -0,0 +1,105 @@
+"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.packageJSONOptionsSchema = 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(/^(?!\/)(?![A-Za-z]:[\\/])(?!(?:\\\\|\/\/)).+/, 'bin target must be a relative path like ./cli.js');
+const binRecordSchema = zod_1.z.record(binNameSchema, binTargetSchema);
+const binEntrySchema = zod_1.z
+    .string()
+    .regex(/^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?=(?!\/)(?![A-Za-z]:[\\/])(?!(?:\\\\|\/\/)).+$/, 'expected <name=relative/path>');
+const binEntriesToRecordSchema = zod_1.z
+    .array(binEntrySchema)
+    .optional()
+    .default([])
+    .transform((entries) => Object.fromEntries(entries.map((entry) => {
+    const [name, target] = entry.split('=', 2);
+    return [name, target];
+})));
+// -------------------------------------------
+// package.json Schema: Just bin for now
+// -------------------------------------------
+const packageJSONOptionsSchema = zod_1.z.object({
+    bin: binRecordSchema.optional(),
+});
+exports.packageJSONOptionsSchema = packageJSONOptionsSchema;
+// -------------------------------------------
+// symlx.config.json options: should allow configuring all options
+// -------------------------------------------
+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: binRecordSchema.optional(),
+    binResolutionStrategy: zod_1.z.enum(['replace', 'merge']).optional(),
+});
+exports.configFileOptionsSchema = configFileOptionsSchema;
+// -------------------------------------------
+// varying command inline options: highest priority in field:value resolution
+// -------------------------------------------
+const serveInlineOptionsSchema = configFileOptionsSchema
+    .pick({
+    binDir: true,
+    collision: true,
+    nonInteractive: true,
+    binResolutionStrategy: true,
+})
+    .extend({
+    bin: binEntriesToRecordSchema,
+});
+exports.serveInlineOptionsSchema = serveInlineOptionsSchema;

package/dist/{services → lib}/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("./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
@@ -28,25 +63,6 @@ function isProcessAlive(pid) {
         return code !== 'ESRCH';
     }
 }
-// Session files are best-effort state; deletion failure should not fail the command.
-function deleteFile(filePath) {
-    try {
-        node_fs_1.default.unlinkSync(filePath);
-    }
-    catch {
-        // 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) {
@@ -67,7 +83,6 @@ function cleanupLinks(links) {
         }
     }
 }
-// -----------------------------------------------------------
 // Ensures runtime directories exist before linking/saving sessions.
 function ensureSymlxDirectories(binDir, sessionDir) {
     node_fs_1.default.mkdirSync(binDir, { recursive: true });
@@ -79,25 +94,31 @@ 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);
         // Delete any files that are not .json, session files can only be JSON
         if (!entry.endsWith('.json')) {
-            deleteFile(filePath);
+            (0, utils_1.deleteFile)(filePath);
             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);
+            (0, utils_1.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);
+            (0, utils_1.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) {
@@ -111,5 +132,5 @@ function createSessionFilePath(sessionDir) {
 // Cleanup for the active process/session.
 function cleanupSession(sessionPath, links) {
     cleanupLinks(links);
-    deleteFile(sessionPath);
+    (0, utils_1.deleteFile)(sessionPath);
 }

package/dist/lib/utils.js

@@ -0,0 +1,127 @@
+"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;
+exports.loadPackageJSONOptions = loadPackageJSONOptions;
+exports.deleteFile = deleteFile;
+exports.pathContainsDir = pathContainsDir;
+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 formatReadError(error) {
+    if (error instanceof Error && error.message) {
+        return error.message;
+    }
+    return String(error);
+}
+function readJSONFileWithIssue(filePath, label) {
+    try {
+        const raw = node_fs_1.default.readFileSync(filePath, 'utf8');
+        return { data: JSON.parse(raw) };
+    }
+    catch (error) {
+        return {
+            issue: `invalid ${label} at ${filePath}: ${formatReadError(error)}`,
+        };
+    }
+}
+function loadConfigFileOptions(cwd) {
+    const configPath = node_path_1.default.join(cwd, 'symlx.config.json');
+    if (!node_fs_1.default.existsSync(configPath)) {
+        return {};
+    }
+    const result = readJSONFileWithIssue(configPath, 'symlx.config.json');
+    if (result.issue) {
+        return { issue: result.issue };
+    }
+    return { options: result.data };
+}
+// 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) {
+        return undefined;
+    }
+    if (packageName.startsWith('@')) {
+        const parts = packageName.split('/');
+        if (parts.length !== 2 || !parts[1]) {
+            return undefined;
+        }
+        return parts[1];
+    }
+    return packageName;
+}
+// Loads and validates all bin entries for the current project.
+// Returned map is command name => absolute target file path.
+function loadPackageJSONOptions(cwd) {
+    const packageJsonPath = node_path_1.default.join(cwd, 'package.json');
+    if (!node_fs_1.default.existsSync(packageJsonPath)) {
+        return {
+            bin: {},
+            issues: [`package.json not found at ${packageJsonPath}`],
+        };
+    }
+    const parsedPackageJSON = readJSONFileWithIssue(packageJsonPath, 'package.json');
+    if (parsedPackageJSON.issue) {
+        return {
+            bin: {},
+            issues: [parsedPackageJSON.issue],
+        };
+    }
+    const packageJson = parsedPackageJSON.data;
+    if (!packageJson || !packageJson.bin) {
+        return {
+            bin: {},
+            issues: [],
+        };
+    }
+    const bin = {};
+    const issues = [];
+    if (typeof packageJson.bin === 'string') {
+        const inferredBinName = inferBinName(packageJson.name);
+        if (inferredBinName) {
+            bin[inferredBinName] = packageJson.bin;
+        }
+        else {
+            issues.push('bin field is a string, but could not infer name, set a valid package.json "name"');
+        }
+    }
+    else {
+        for (const [name, relTarget] of Object.entries(packageJson.bin)) {
+            bin[name] = relTarget;
+        }
+    }
+    return { bin, issues };
+}
+// Session files are best-effort state; deletion failure should not fail the command.
+function deleteFile(filePath) {
+    try {
+        node_fs_1.default.unlinkSync(filePath);
+    }
+    catch {
+        // Best-effort cleanup.
+    }
+}
+// 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/validator.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validatePackageJSONOptions = validatePackageJSONOptions;
+exports.validateConfigFileOptions = validateConfigFileOptions;
+exports.validateInlineOptions = validateInlineOptions;
+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 validatePackageJSONOptions(input) {
+    const result = schema_1.packageJSONOptionsSchema.safeParse(input || {});
+    if (!result.success) {
+        return { bin: {}, issues: result.error.issues.map((i) => i.message) };
+    }
+    return { ...result.data, issues: [] };
+}
+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;
+}
+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;
+}

package/dist/postinstall.js

@@ -0,0 +1,142 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const PREFIX = '[symlx]';
+const START = '# >>> symlx path >>>';
+const END = '# <<< symlx path <<<';
+const BIN_PATH = '$HOME/.symlx/bin';
+const PROFILE_BASENAMES = ['.zprofile', '.zshrc', '.bashrc'];
+function info(message) {
+    process.stdout.write(`${PREFIX} ${message}\n`);
+}
+function warn(message) {
+    process.stderr.write(`${PREFIX} ${message}\n`);
+}
+function printManualPathSetupGuidance() {
+    if (process.platform === 'win32') {
+        info('manual setup (PowerShell):');
+        info('[Environment]::SetEnvironmentVariable("Path", "$env:USERPROFILE\\\\.symlx\\\\bin;$env:Path", "User")');
+        info('then open a new terminal');
+        return;
+    }
+    info('manual setup: add this to ~/.zshrc, ~/.zprofile, or ~/.bashrc');
+    info(START);
+    info('if [[ ":$PATH:" != *":$HOME/.symlx/bin:"* ]]; then');
+    info('  export PATH="$HOME/.symlx/bin:$PATH"');
+    info('fi');
+    info(END);
+    info('then run: source ~/.zshrc (or your active shell profile)');
+}
+function resolveProfilePaths(homeDir) {
+    return PROFILE_BASENAMES.map((basename) => node_path_1.default.join(homeDir, basename));
+}
+function toHomeRelativePath(filePath, homeDir) {
+    if (filePath.startsWith(`${homeDir}${node_path_1.default.sep}`)) {
+        return `~/${node_path_1.default.relative(homeDir, filePath)}`;
+    }
+    return filePath;
+}
+function getPreferredSourcePath(updatedPaths) {
+    const shell = process.env.SHELL ?? '';
+    const preferredBasename = shell.includes('zsh')
+        ? '.zshrc'
+        : shell.includes('bash')
+            ? '.bashrc'
+            : undefined;
+    if (!preferredBasename) {
+        return updatedPaths[0];
+    }
+    return (updatedPaths.find((filePath) => node_path_1.default.basename(filePath) === preferredBasename) ??
+        updatedPaths[0]);
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function buildPathBlock() {
+    return [
+        START,
+        `if [[ ":$PATH:" != *":${BIN_PATH}:"* ]]; then`,
+        `  export PATH="${BIN_PATH}:$PATH"`,
+        'fi',
+        END,
+    ].join('\n');
+}
+function ensureTrailingNewline(value) {
+    return value.endsWith('\n') ? value : `${value}\n`;
+}
+function upsertProfileBlock(filePath, block) {
+    const exists = node_fs_1.default.existsSync(filePath);
+    const current = exists ? node_fs_1.default.readFileSync(filePath, 'utf8') : '';
+    const normalizedCurrent = current.replace(/\r\n/g, '\n');
+    const markerPattern = new RegExp(`${escapeRegExp(START)}[\\s\\S]*?${escapeRegExp(END)}\\n?`, 'm');
+    let next;
+    if (markerPattern.test(normalizedCurrent)) {
+        next = normalizedCurrent.replace(markerPattern, `${block}\n`);
+    }
+    else if (normalizedCurrent.trim().length === 0) {
+        next = `${block}\n`;
+    }
+    else {
+        next = `${ensureTrailingNewline(normalizedCurrent)}\n${block}\n`;
+    }
+    if (next === normalizedCurrent) {
+        return false;
+    }
+    node_fs_1.default.writeFileSync(filePath, next, 'utf8');
+    return true;
+}
+function run() {
+    if (process.env.SYMLX_SKIP_PATH_SETUP === '1') {
+        info('skipping PATH setup because SYMLX_SKIP_PATH_SETUP=1');
+        printManualPathSetupGuidance();
+        return;
+    }
+    if (process.platform === 'win32') {
+        info('skipping shell profile PATH setup on Windows');
+        printManualPathSetupGuidance();
+        return;
+    }
+    const homeDir = node_os_1.default.homedir();
+    if (!homeDir) {
+        warn('could not resolve home directory; skipping PATH setup');
+        printManualPathSetupGuidance();
+        return;
+    }
+    const block = buildPathBlock();
+    const profilePaths = resolveProfilePaths(homeDir);
+    const existingPaths = profilePaths.filter((filePath) => node_fs_1.default.existsSync(filePath));
+    const targets = existingPaths.length > 0 ? existingPaths : [profilePaths[0]];
+    const updated = [];
+    for (const target of targets) {
+        try {
+            const changed = upsertProfileBlock(target, block);
+            if (changed) {
+                updated.push(target);
+            }
+        }
+        catch (error) {
+            warn(`could not update ${target}: ${String(error)}`);
+        }
+    }
+    if (updated.length > 0) {
+        info(`added ${BIN_PATH} to PATH in:`);
+        for (const target of updated) {
+            info(`- ${target}`);
+        }
+        const preferredSourcePath = getPreferredSourcePath(updated);
+        if (preferredSourcePath) {
+            const sourceTarget = toHomeRelativePath(preferredSourcePath, homeDir);
+            info(`run now: source ${sourceTarget}`);
+        }
+        info('or open a new shell to apply immediately');
+    }
+    else {
+        info(`PATH setup already present (${BIN_PATH})`);
+    }
+}
+run();

package/dist/preinstall.js

@@ -0,0 +1,10 @@
+"use strict";
+const PREFIX = '[symlx]';
+function info(message) {
+    process.stdout.write(`${PREFIX} ${message}\n`);
+}
+function run() {
+    info('notice: install will update your shell profile PATH with $HOME/.symlx/bin');
+    info('set SYMLX_SKIP_PATH_SETUP=1 to skip automatic PATH setup');
+}
+run();

package/dist/ui/{collision-prompt.js → prompts.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;
 }