sitevision-cli 0.1.2 → 0.3.1-beta.1

package/dist/app.js

@@ -8,6 +8,7 @@ import { BuildScreen } from './commands/build.js';
 import { DeployScreen } from './commands/deploy.js';
 import { SignScreen } from './commands/sign.js';
 import { SigningPropertiesForm } from './components/SigningPropertiesForm.js';
+import { setDeployPassword as saveDeployPassword, setSigningPassword as saveSigningPassword } from './utils/keychain.js';
 export default function App({ project }) {
     const [state, setState] = useState('setup');
     const [currentCommand, setCurrentCommand] = useState('');
@@ -23,8 +24,11 @@ export default function App({ project }) {
             return project.devProperties;
         return { ...project.devProperties, password: devPassword };
     };
-    const handleDevPasswordSubmit = (password) => {
+    const handleDevPasswordSubmit = (password, remember) => {
         setDevPassword(password);
+        if (remember && project.devProperties?.domain && project.devProperties.username && password) {
+            saveDeployPassword(project.devProperties.domain, project.devProperties.username, password);
+        }
         // Continue to the intended command
         if (currentCommand === 'dev' || currentCommand === 'dev-signed') {
             if (currentCommand === 'dev-signed' && !signingPassword) {
@@ -38,8 +42,11 @@ export default function App({ project }) {
             setState('deploy');
         }
     };
-    const handleSigningPasswordSubmit = (password) => {
+    const handleSigningPasswordSubmit = (password, remember) => {
         setSigningPassword(password);
+        if (remember && project.devProperties?.signingUsername && password) {
+            saveSigningPassword(project.devProperties.signingUsername, password);
+        }
         if (currentCommand === 'dev-signed') {
             setState('dev');
         }
@@ -133,14 +140,16 @@ export default function App({ project }) {
         return React.createElement(InfoScreen, { project: project, onBack: () => setState('menu') });
     }
     if (state === 'dev-password-input') {
-        return (React.createElement(PasswordInput, { key: "dev-password", label: "Enter Development Password (usually Sitevision Cloud Password)", onSubmit: handleDevPasswordSubmit, onCancel: () => setState('menu') }));
+        return (React.createElement(PasswordInput, { key: "dev-password", label: "Enter Development Password (usually Sitevision Cloud Password)", showRememberOption: Boolean(project.devProperties?.domain && project.devProperties?.username), onSubmit: handleDevPasswordSubmit, onCancel: () => setState('menu') }));
     }
     if (state === 'signing-password-input') {
-        return (React.createElement(PasswordInput, { key: "signing-password", label: "Enter Signing Password (developer.sitevision.se)", onSubmit: handleSigningPasswordSubmit, onCancel: () => setState('menu') }));
+        return (React.createElement(PasswordInput, { key: "signing-password", label: "Enter Signing Password (developer.sitevision.se)", showRememberOption: Boolean(project.devProperties?.signingUsername), onSubmit: handleSigningPasswordSubmit, onCancel: () => setState('menu') }));
     }
     if (state === 'dev') {
         return (React.createElement(DevScreen, { projectRoot: project.root, manifest: project.manifest, devProperties: getEffectiveDevProperties(), signed: currentCommand === 'dev-signed', onBack: () => setState('menu'), onRetryCredentials: () => {
                 setDevPassword('');
+                if (project.devProperties)
+                    project.devProperties.password = undefined;
                 if (currentCommand === 'dev-signed') {
                     setSigningPassword('');
                 }
@@ -165,6 +174,8 @@ export default function App({ project }) {
     if (state === 'deploy') {
         return (React.createElement(DeployScreen, { projectRoot: project.root, manifest: project.manifest, devProperties: getEffectiveDevProperties(), force: currentCommand === 'deploy-force', production: currentCommand === 'deploy-production', activate: currentCommand === 'deploy-production', onBack: () => setState('menu'), onRetryCredentials: () => {
                 setDevPassword('');
+                if (project.devProperties)
+                    project.devProperties.password = undefined;
                 setState('dev-password-input');
             } }));
     }

package/dist/cli.js

@@ -4,13 +4,12 @@ import { render } from 'ink';
 import { Text, Box } from 'ink';
 import meow from 'meow';
 import { readFileSync } from 'node:fs';
-import updateNotifier from 'update-notifier';
 import App from './app.js';
 import { getCommand } from './commands/index.js';
-import { requireProject } from './utils/project-detection.js';
-// Check for updates
+import { requireProject, migrateLegacyPassword } from './utils/project-detection.js';
+import { promptYesNo } from './utils/password-prompt.js';
+import { checkForUpdate } from './utils/version-check.js';
 const pkg = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
-updateNotifier({ pkg }).notify();
 const cli = meow(`
 	Usage
 	  $ svc                    Start interactive menu
@@ -55,6 +54,12 @@ const cli = meow(`
 });
 const [commandName, ...args] = cli.input;
 async function main() {
+    // Show the CLI version on startup, and check npm for a newer release.
+    console.log(`\x1b[36msvc v${pkg.version}\x1b[0m`);
+    const latestVersion = await checkForUpdate(pkg.name, pkg.version);
+    if (latestVersion) {
+        console.log(`\x1b[33m  ↑ update available: ${pkg.version} → ${latestVersion}  (run: npm i -g ${pkg.name})\x1b[0m`);
+    }
     // Check if we're in a Sitevision project
     const project = (() => {
         try {
@@ -87,6 +92,22 @@ async function main() {
                 " to see available commands")));
         process.exit(1);
     }
+    // Offer to migrate a legacy plaintext password into the OS keychain.
+    // Interactive `svc` handles this in SetupFlow; this covers direct commands
+    // (svc deploy/dev/sign/…). Skip on non-TTY stdin (e.g. CI) where prompting
+    // would fail — the plaintext password is still used for this run.
+    if (project.hasLegacyPassword && process.stdin.isTTY) {
+        console.log('\n\x1b[33m⚠ Plaintext password found in .dev_properties.json\x1b[0m');
+        const move = await promptYesNo('Move it to the OS keychain and remove it from the file? (y/N): ');
+        if (move) {
+            if (migrateLegacyPassword(project)) {
+                console.log('\x1b[32m✓ Password moved to keychain.\x1b[0m\n');
+            }
+            else {
+                console.log('\x1b[31mCould not access keychain; leaving the file unchanged.\x1b[0m\n');
+            }
+        }
+    }
     // Execute the command
     await command.execute({
         project,

package/dist/commands/deploy.js

@@ -4,6 +4,8 @@ import { StatusIndicator } from '../components/StatusIndicator.js';
 import { deployApp, deployProduction } from '../utils/sitevision-api.js';
 import { getZipPath, getSignedZipPath, getAppType, } from '../utils/project-detection.js';
 import { zipExists } from '../utils/zip.js';
+import { promptPassword, promptYesNo } from '../utils/password-prompt.js';
+import { setDeployPassword } from '../utils/keychain.js';
 export function DeployScreen({ projectRoot, manifest, devProperties, force, production, activate, signingPassword, onBack, onRetryCredentials, }) {
     const [state, setState] = React.useState({
         status: 'deploying',
@@ -144,9 +146,24 @@ export const deployCommand = {
         // Check if dev properties are configured
         if (!project.hasDevProperties || !project.devProperties) {
             console.log('\n\x1b[33mDeployment credentials not configured.\x1b[0m');
-            console.log('Create a .dev_properties.json file with domain, siteName, addonName, username, and password.\n');
+            console.log('Create a .dev_properties.json file with domain, siteName, addonName, and username, then run setup.\n');
             return;
         }
+        // Resolve deploy password (already loaded from keychain/env in detectProject — prompt if missing)
+        if (!project.devProperties.password) {
+            const { domain, username } = project.devProperties;
+            console.log('');
+            const password = await promptPassword(`Deploy password for ${username}@${domain}: `);
+            if (!password) {
+                console.log('\x1b[31mError: Password is required\x1b[0m');
+                return;
+            }
+            const remember = await promptYesNo('Save password to OS keychain? (y/N): ');
+            if (remember && domain && username) {
+                setDeployPassword(domain, username, password);
+            }
+            project.devProperties.password = password;
+        }
         const production = Boolean(flags['production']);
         const force = Boolean(flags['force']);
         const activate = Boolean(flags['activate']);

package/dist/commands/dev.js

@@ -2,8 +2,9 @@ import React from 'react';
 import { render, Box, Text, useApp, useInput } from 'ink';
 import { StatusIndicator } from '../components/StatusIndicator.js';
 import { WebpackRunner } from '../utils/webpack-runner.js';
-import { promptPassword } from '../utils/password-prompt.js';
+import { promptPassword, promptYesNo } from '../utils/password-prompt.js';
 import { signApp, deployApp } from '../utils/sitevision-api.js';
+import { getSigningPassword, setSigningPassword, setDeployPassword } from '../utils/keychain.js';
 import { copyStaticToBuild, createBuildZip, cleanBuild, } from '../utils/zip.js';
 import { isBundledApp, getAppType, getFullAppId, getZipPath, getSignedZipPath, } from '../utils/project-detection.js';
 export function DevScreen({ projectRoot, manifest, devProperties, signed, signingCredentials, onBack, onRetryCredentials, }) {
@@ -261,26 +262,53 @@ export const devCommand = {
         // Check if dev properties are configured
         if (!project.hasDevProperties || !project.devProperties) {
             console.log('\n\x1b[33mDeployment credentials not configured.\x1b[0m');
-            console.log('Create a .dev_properties.json file with domain, siteName, addonName, username, and password.\n');
+            console.log('Create a .dev_properties.json file with domain, siteName, addonName, and username, then run setup.\n');
             return;
         }
+        // Resolve deploy password (already loaded from keychain/env in detectProject — prompt if missing)
+        if (!project.devProperties.password) {
+            const { domain, username } = project.devProperties;
+            console.log('');
+            const pw = await promptPassword(`Deploy password for ${username}@${domain}: `);
+            if (!pw) {
+                console.log('\x1b[31mError: Password is required\x1b[0m');
+                return;
+            }
+            const remember = await promptYesNo('Save password to OS keychain? (y/N): ');
+            if (remember && domain && username) {
+                setDeployPassword(domain, username, pw);
+            }
+            project.devProperties.password = pw;
+        }
         const signed = Boolean(flags['signed']);
         let signingCredentials;
-        // If signed mode, prompt for signing password
+        // If signed mode, resolve signing password (keychain → env → prompt)
         if (signed) {
             if (!project.hasSigningProperties || !project.devProperties.signingUsername) {
                 console.log('\n\x1b[33mSigning credentials not configured.\x1b[0m');
                 console.log('Run \x1b[36msetup-signing\x1b[0m to configure credentials.\n');
                 return;
             }
-            console.log('');
-            const password = await promptPassword('Signing password (developer.sitevision.se): ');
+            const signingUsername = project.devProperties.signingUsername;
+            let password = getSigningPassword(signingUsername) || process.env['SITEVISION_SIGNING_PASSWORD'] || '';
+            let promptedManually = false;
+            if (!password) {
+                console.log('');
+                password = await promptPassword('Signing password (developer.sitevision.se): ');
+                promptedManually = true;
+            }
             if (!password) {
                 console.log('\x1b[31mError: Password is required for signed mode\x1b[0m');
                 return;
             }
+            if (promptedManually) {
+                const remember = await promptYesNo('Save password to OS keychain? (y/N): ');
+                if (remember) {
+                    setSigningPassword(signingUsername, password);
+                }
+            }
             signingCredentials = {
-                username: project.devProperties.signingUsername,
+                username: signingUsername,
                 password,
                 certificateName: project.devProperties.certificateName,
             };

package/dist/commands/setup-signing.js

@@ -64,8 +64,8 @@ export const setupSigningCommand = {
                 certificateName = defaultCertName;
             }
             rl.close();
-            // Update dev properties (remove any stored password from old config)
-            const { signingPassword: _removed, ...cleanedProperties } = existingProperties;
+            // Update dev properties (strip any plaintext passwords — they live in the keychain)
+            const { signingPassword: _signingRemoved, password: _passwordRemoved, ...cleanedProperties } = existingProperties;
             const updatedProperties = {
                 ...cleanedProperties,
                 signingUsername,

package/dist/commands/sign.js

@@ -2,7 +2,8 @@ import React from 'react';
 import { render, Box, Text, useInput } from 'ink';
 import { StatusIndicator } from '../components/StatusIndicator.js';
 import { signApp } from '../utils/sitevision-api.js';
-import { promptPassword } from '../utils/password-prompt.js';
+import { promptPassword, promptYesNo } from '../utils/password-prompt.js';
+import { getSigningPassword, setSigningPassword } from '../utils/keychain.js';
 import { getZipPath, getSignedZipPath, } from '../utils/project-detection.js';
 import { formatFileSize, getZipSize, zipExists } from '../utils/zip.js';
 export function SignScreen({ projectRoot, manifest, devProperties, password, onBack, onRetryCredentials }) {
@@ -90,13 +91,25 @@ export const signCommand = {
             console.log('Run \x1b[36msetup-signing\x1b[0m to configure credentials.\n');
             return;
         }
-        // Prompt for password
-        console.log('');
-        const password = await promptPassword('Signing password (developer.sitevision.se: ');
+        const signingUsername = project.devProperties.signingUsername;
+        // Try keychain first, then env var, then prompt
+        let password = getSigningPassword(signingUsername) || process.env['SITEVISION_SIGNING_PASSWORD'] || '';
+        let promptedManually = false;
+        if (!password) {
+            console.log('');
+            password = await promptPassword('Signing password (developer.sitevision.se): ');
+            promptedManually = true;
+        }
         if (!password) {
             console.log('\x1b[31mError: Password is required\x1b[0m');
             return;
         }
+        if (promptedManually) {
+            const remember = await promptYesNo('Save password to OS keychain? (y/N): ');
+            if (remember) {
+                setSigningPassword(signingUsername, password);
+            }
+        }
         const { waitUntilExit } = render(React.createElement(SignScreen, { projectRoot: project.root, manifest: project.manifest, devProperties: project.devProperties, password: password }));
         await waitUntilExit();
     },

package/dist/components/DevPropertiesForm.js

@@ -2,6 +2,7 @@ import React, { useState } from 'react';
 import { Box, Text, useInput } from 'ink';
 import { TextInput } from './TextInput.js';
 import { writeDevProperties } from '../utils/project-detection.js';
+import { setDeployPassword, deleteDeployPassword } from '../utils/keychain.js';
 const STEPS = [
     { id: 'domain', label: 'Domain' },
     { id: 'siteName', label: 'Site Name' },
@@ -28,8 +29,16 @@ export function DevPropertiesForm({ projectRoot, initialProperties, packageJson,
             setStepIndex(stepIndex + 1);
         }
         else {
-            // Save and finish
-            writeDevProperties(projectRoot, newProperties);
+            const finalProperties = newProperties;
+            const { password, domain, username } = finalProperties;
+            if (password && domain && username) {
+                setDeployPassword(domain, username, password);
+            }
+            else if (domain && username) {
+                // Empty password — clear any stale keychain entry so deploy falls through to prompt
+                deleteDeployPassword(domain, username);
+            }
+            writeDevProperties(projectRoot, finalProperties);
             onComplete();
         }
     };
@@ -44,7 +53,7 @@ export function DevPropertiesForm({ projectRoot, initialProperties, packageJson,
             case 'username':
                 return (React.createElement(TextInput, { key: "username", label: "Username (usually your Sitevision Cloud email)", defaultValue: properties.username, onSubmit: (value) => handleNext('username', value), onCancel: onCancel }));
             case 'password':
-                return (React.createElement(TextInput, { key: "password", label: "Password (Optional - leave empty to prompt on each run)", type: "password", defaultValue: properties.password, onSubmit: (value) => handleNext('password', value), onCancel: onCancel }));
+                return (React.createElement(TextInput, { key: "password", label: "Password (saved in OS keychain \u2014 leave empty to prompt on each run)", type: "password", defaultValue: properties.password, onSubmit: (value) => handleNext('password', value), onCancel: onCancel }));
             case 'useHTTP':
                 return (React.createElement(BooleanInput, { key: "useHTTP", label: "Use HTTP for deployment? (y/n)", defaultValue: properties.useHTTPForDevDeploy, onSubmit: (value) => handleNext('useHTTPForDevDeploy', value) }));
             default:

package/dist/components/PasswordInput.d.ts

@@ -1,8 +1,9 @@
 import React from 'react';
 interface Props {
     label?: string;
-    onSubmit: (password: string) => void;
+    showRememberOption?: boolean;
+    onSubmit: (password: string, remember: boolean) => void;
     onCancel: () => void;
 }
-export declare function PasswordInput({ label, onSubmit, onCancel }: Props): React.JSX.Element;
+export declare function PasswordInput({ label, showRememberOption, onSubmit, onCancel }: Props): React.JSX.Element;
 export {};

package/dist/components/PasswordInput.js

@@ -1,16 +1,21 @@
 import React, { useState } from 'react';
 import { Box, Text, useInput } from 'ink';
-export function PasswordInput({ label = 'Enter Signing Password', onSubmit, onCancel }) {
+export function PasswordInput({ label = 'Enter Signing Password', showRememberOption = false, onSubmit, onCancel }) {
     const [password, setPassword] = useState('');
+    const [remember, setRemember] = useState(false);
     useInput((input, key) => {
         if (key.return) {
-            onSubmit(password);
+            onSubmit(password, remember);
             return;
         }
         if (key.escape) {
             onCancel();
             return;
         }
+        if (key.tab && showRememberOption) {
+            setRemember((prev) => !prev);
+            return;
+        }
         if (key.delete || key.backspace) {
             setPassword((prev) => prev.slice(0, -1));
             return;
@@ -25,6 +30,13 @@ export function PasswordInput({ label = 'Enter Signing Password', onSubmit, onCa
             React.createElement(Text, { bold: true, color: "cyan" }, label)),
         React.createElement(Box, { borderStyle: "round", borderColor: "cyan", paddingX: 1 },
             React.createElement(Text, null, '*'.repeat(password.length))),
+        showRememberOption && (React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { dimColor: true }, "Save to OS keychain: "),
+            React.createElement(Text, { color: remember ? 'green' : 'gray' },
+                "[",
+                remember ? 'x' : ' ',
+                "]"),
+            React.createElement(Text, { dimColor: true }, " (Tab to toggle)"))),
         React.createElement(Box, { marginTop: 1 },
             React.createElement(Text, { dimColor: true }, "Press Enter to submit, Esc to cancel"))));
 }

package/dist/components/SetupFlow.js

@@ -1,6 +1,6 @@
 import React, { useState, useEffect } from 'react';
 import { Box, Text, useInput } from 'ink';
-import { getAppType } from '../utils/project-detection.js';
+import { getAppType, migrateLegacyPassword } from '../utils/project-detection.js';
 import { ProcessRunner } from '../utils/process-runner.js';
 import { ProcessOutputComponent } from './ProcessOutput.js';
 import { StatusIndicator } from './StatusIndicator.js';
@@ -23,7 +23,12 @@ export function SetupFlow({ project, onComplete }) {
         }
         else if (step === 'check-dev-properties') {
             if (project.hasDevProperties) {
-                setStep('check-signing-properties');
+                if (project.hasLegacyPassword) {
+                    setStep('confirm-password-migration');
+                }
+                else {
+                    setStep('check-signing-properties');
+                }
             }
             else {
                 setStep('confirm-dev-setup');
@@ -75,6 +80,15 @@ export function SetupFlow({ project, onComplete }) {
                 setStep('check-signing-properties');
             }
         }
+        else if (step === 'confirm-password-migration') {
+            if (input === 'y' || input === 'Y') {
+                migrateLegacyPassword(project);
+                setStep('check-signing-properties');
+            }
+            else if (input === 'n' || input === 'N') {
+                setStep('check-signing-properties');
+            }
+        }
         else if (step === 'confirm-signing-setup') {
             if (input === 'y' || input === 'Y') {
                 setStep('setup-signing-properties');
@@ -128,6 +142,17 @@ export function SetupFlow({ project, onComplete }) {
             React.createElement(Box, { marginBottom: 1 },
                 React.createElement(Text, null, "Would you like to set up dev properties? (y/n)"))));
     }
+    // Confirm legacy password migration
+    if (step === 'confirm-password-migration') {
+        return (React.createElement(Box, { flexDirection: "column", padding: 1 },
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, { bold: true, color: "cyan" }, "Sitevision CLI")),
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, { color: "yellow" }, "\u26A0 Plaintext password found in .dev_properties.json")),
+            React.createElement(Box, { marginBottom: 1, flexDirection: "column" },
+                React.createElement(Text, null, "Move it to the OS keychain and remove it from the file? (y/n)"),
+                React.createElement(Text, { dimColor: true }, "Recommended \u2014 storing passwords in project files is insecure."))));
+    }
     // Confirm signing setup
     if (step === 'confirm-signing-setup') {
         return (React.createElement(Box, { flexDirection: "column", padding: 1 },

package/dist/types/index.d.ts

@@ -27,14 +27,18 @@ export interface SitevisionManifest {
     categories?: string[];
 }
 /**
- * Development properties stored in .dev_properties.json
+ * Development properties.
+ *
+ * Persisted fields live in .dev_properties.json. `password` is runtime-only:
+ * resolved from the OS keychain (or a legacy plaintext file during migration)
+ * and never written back to disk.
  */
 export interface DevProperties {
     domain: string;
     siteName: string;
     addonName: string;
     username: string;
-    password: string;
+    password?: string;
     useHTTPForDevDeploy?: boolean;
     signingUsername?: string;
     certificateName?: string;
@@ -80,6 +84,7 @@ export interface ProjectInfo {
     manifest: SitevisionManifest;
     hasDevProperties: boolean;
     hasSigningProperties: boolean;
+    hasLegacyPassword: boolean;
     devProperties?: DevProperties;
     packageJson: PackageJson;
     hasSitevisionScripts: boolean;

package/dist/utils/keychain.d.ts

@@ -0,0 +1,6 @@
+export declare function getDeployPassword(domain: string, username: string): string | null;
+export declare function setDeployPassword(domain: string, username: string, password: string): boolean;
+export declare function deleteDeployPassword(domain: string, username: string): void;
+export declare function getSigningPassword(username: string): string | null;
+export declare function setSigningPassword(username: string, password: string): boolean;
+export declare function deleteSigningPassword(username: string): void;

package/dist/utils/keychain.js

@@ -0,0 +1,63 @@
+import { Entry } from '@napi-rs/keyring';
+const SERVICE = 'sitevision-cli';
+function deployAccount(domain, username) {
+    return `deploy:${username}@${domain}`;
+}
+function signingAccount(username) {
+    return `signing:${username}`;
+}
+function safeGet(account) {
+    try {
+        return new Entry(SERVICE, account).getPassword();
+    }
+    catch {
+        return null;
+    }
+}
+function safeSet(account, password) {
+    try {
+        new Entry(SERVICE, account).setPassword(password);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function safeDelete(account) {
+    try {
+        new Entry(SERVICE, account).deletePassword();
+    }
+    catch {
+        // ignore
+    }
+}
+export function getDeployPassword(domain, username) {
+    if (!domain || !username)
+        return null;
+    return safeGet(deployAccount(domain, username));
+}
+export function setDeployPassword(domain, username, password) {
+    if (!domain || !username || !password)
+        return false;
+    return safeSet(deployAccount(domain, username), password);
+}
+export function deleteDeployPassword(domain, username) {
+    if (!domain || !username)
+        return;
+    safeDelete(deployAccount(domain, username));
+}
+export function getSigningPassword(username) {
+    if (!username)
+        return null;
+    return safeGet(signingAccount(username));
+}
+export function setSigningPassword(username, password) {
+    if (!username || !password)
+        return false;
+    return safeSet(signingAccount(username), password);
+}
+export function deleteSigningPassword(username) {
+    if (!username)
+        return;
+    safeDelete(signingAccount(username));
+}

package/dist/utils/password-prompt.d.ts

@@ -1,3 +1,7 @@
+/**
+ * Prompt for a yes/no answer. Returns true for y/Y, false otherwise (incl. empty / Enter).
+ */
+export declare function promptYesNo(prompt: string): Promise<boolean>;
 /**
  * Prompt for password input with masked display
  */

package/dist/utils/password-prompt.js

@@ -1,3 +1,27 @@
+/**
+ * Prompt for a yes/no answer. Returns true for y/Y, false otherwise (incl. empty / Enter).
+ */
+export function promptYesNo(prompt) {
+    return new Promise((resolve) => {
+        process.stdout.write(prompt);
+        const stdin = process.stdin;
+        stdin.setRawMode(true);
+        stdin.resume();
+        stdin.setEncoding('utf8');
+        const onData = (data) => {
+            const char = data[0] || '';
+            stdin.setRawMode(false);
+            stdin.removeListener('data', onData);
+            stdin.pause();
+            process.stdout.write(`${char}\n`);
+            if (char.charCodeAt(0) === 3) {
+                process.exit();
+            }
+            resolve(char === 'y' || char === 'Y');
+        };
+        stdin.on('data', onData);
+    });
+}
 /**
  * Prompt for password input with masked display
  */

package/dist/utils/project-detection.d.ts

@@ -1,19 +1,5 @@
-import type { SitevisionManifest, DevProperties, ProjectPaths, SimpleAppType, PackageJson, ApiEndpoints } from '../types/index.js';
-export type { SitevisionManifest, DevProperties } from '../types/index.js';
-/**
- * Project information with paths
- */
-export interface ProjectInfo {
-    root: string;
-    manifest: SitevisionManifest;
-    hasDevProperties: boolean;
-    hasSigningProperties: boolean;
-    devProperties?: DevProperties;
-    packageJson: PackageJson;
-    hasSitevisionScripts: boolean;
-    hasNodeModules: boolean;
-    paths: ProjectPaths;
-}
+import type { SitevisionManifest, DevProperties, ProjectInfo, ProjectPaths, SimpleAppType, ApiEndpoints } from '../types/index.js';
+export type { SitevisionManifest, DevProperties, ProjectInfo } from '../types/index.js';
 /**
  * Get standard project paths for a given root directory
  */
@@ -86,9 +72,18 @@ export declare function isBundledApp(manifest: SitevisionManifest): boolean;
  */
 export declare function readDevProperties(projectRoot: string): DevProperties | null;
 /**
- * Write dev properties to file
+ * Write dev properties to file. The `password` field is never persisted —
+ * it is held in the OS keychain instead.
  */
 export declare function writeDevProperties(projectRoot: string, properties: DevProperties): void;
+/**
+ * Move a plaintext password from .dev_properties.json into the OS keychain and
+ * strip it from the file. Returns true if the password was migrated.
+ *
+ * The in-memory `project.devProperties.password` is intentionally left intact
+ * so the current invocation can keep using it; only the on-disk copy is removed.
+ */
+export declare function migrateLegacyPassword(project: ProjectInfo): boolean;
 /**
  * Ensure the dist directory exists
  */

package/dist/utils/project-detection.js

@@ -1,5 +1,6 @@
 import fs from 'fs';
 import path from 'path';
+import { getDeployPassword, setDeployPassword } from './keychain.js';
 // =============================================================================
 // PATH UTILITIES
 // =============================================================================
@@ -173,10 +174,26 @@ export function detectProject(cwd = process.cwd()) {
         const devPropertiesPath = findDevPropertiesPath(cwd);
         let devProperties;
         let hasDevProperties = false;
+        let hasLegacyPassword = false;
         if (devPropertiesPath) {
             hasDevProperties = true;
             try {
-                devProperties = JSON.parse(fs.readFileSync(devPropertiesPath, 'utf-8'));
+                const parsed = JSON.parse(fs.readFileSync(devPropertiesPath, 'utf-8'));
+                hasLegacyPassword = typeof parsed.password === 'string' && parsed.password.length > 0;
+                devProperties = parsed;
+                // Resolve deploy password: env var > keychain (file is legacy-only)
+                if (!hasLegacyPassword && devProperties.domain && devProperties.username) {
+                    const envPassword = process.env['SITEVISION_DEPLOY_PASSWORD'];
+                    if (envPassword) {
+                        devProperties.password = envPassword;
+                    }
+                    else {
+                        const stored = getDeployPassword(devProperties.domain, devProperties.username);
+                        if (stored) {
+                            devProperties.password = stored;
+                        }
+                    }
+                }
             }
             catch {
                 // Invalid dev properties file
@@ -191,6 +208,7 @@ export function detectProject(cwd = process.cwd()) {
             manifest,
             hasDevProperties,
             hasSigningProperties,
+            hasLegacyPassword,
             devProperties,
             packageJson,
             hasSitevisionScripts,
@@ -250,11 +268,33 @@ export function readDevProperties(projectRoot) {
     }
 }
 /**
- * Write dev properties to file
+ * Write dev properties to file. The `password` field is never persisted —
+ * it is held in the OS keychain instead.
  */
 export function writeDevProperties(projectRoot, properties) {
     const devPropertiesPath = findDevPropertiesPath(projectRoot) || getDefaultDevPropertiesPath(projectRoot);
-    fs.writeFileSync(devPropertiesPath, JSON.stringify(properties, null, 2));
+    const { password: _password, ...persisted } = properties;
+    fs.writeFileSync(devPropertiesPath, JSON.stringify(persisted, null, 2));
+}
+/**
+ * Move a plaintext password from .dev_properties.json into the OS keychain and
+ * strip it from the file. Returns true if the password was migrated.
+ *
+ * The in-memory `project.devProperties.password` is intentionally left intact
+ * so the current invocation can keep using it; only the on-disk copy is removed.
+ */
+export function migrateLegacyPassword(project) {
+    if (!project.hasLegacyPassword || !project.devProperties)
+        return false;
+    const { domain, username, password } = project.devProperties;
+    if (!domain || !username || !password)
+        return false;
+    if (!setDeployPassword(domain, username, password))
+        return false;
+    // writeDevProperties strips `password` defensively; keep the in-memory value.
+    writeDevProperties(project.root, project.devProperties);
+    project.hasLegacyPassword = false;
+    return true;
 }
 /**
  * Ensure the dist directory exists

package/dist/utils/version-check.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Check the npm registry for a newer published version of `packageName`.
+ *
+ * Resolves to the latest version string when it is newer than
+ * `currentVersion`, otherwise `null`. Never rejects — network errors,
+ * timeouts, non-200 responses and parse failures all resolve to `null`, so a
+ * failed check never blocks startup or surfaces an error to the user.
+ */
+export declare function checkForUpdate(packageName: string, currentVersion: string, timeoutMs?: number): Promise<string | null>;

package/dist/utils/version-check.js

@@ -0,0 +1,60 @@
+import https from 'node:https';
+/**
+ * True if version `a` is strictly greater than `b`, comparing the numeric
+ * MAJOR.MINOR.PATCH core. Pre-release suffixes (e.g. `-beta.1`) are ignored.
+ */
+function isNewer(a, b) {
+    const core = (v) => (v.split('-')[0] ?? '').split('.');
+    const pa = core(a);
+    const pb = core(b);
+    for (let i = 0; i < 3; i++) {
+        const da = Number.parseInt(pa[i] ?? '0', 10) || 0;
+        const db = Number.parseInt(pb[i] ?? '0', 10) || 0;
+        if (da > db)
+            return true;
+        if (da < db)
+            return false;
+    }
+    return false;
+}
+/**
+ * Check the npm registry for a newer published version of `packageName`.
+ *
+ * Resolves to the latest version string when it is newer than
+ * `currentVersion`, otherwise `null`. Never rejects — network errors,
+ * timeouts, non-200 responses and parse failures all resolve to `null`, so a
+ * failed check never blocks startup or surfaces an error to the user.
+ */
+export function checkForUpdate(packageName, currentVersion, timeoutMs = 1500) {
+    return new Promise((resolve) => {
+        const url = `https://registry.npmjs.org/${encodeURIComponent(packageName)}/latest`;
+        const request = https.get(url, { timeout: timeoutMs, headers: { accept: 'application/json' } }, (response) => {
+            if (response.statusCode !== 200) {
+                response.resume();
+                resolve(null);
+                return;
+            }
+            let body = '';
+            response.setEncoding('utf8');
+            response.on('data', (chunk) => {
+                body += chunk;
+            });
+            response.on('end', () => {
+                try {
+                    const latest = JSON.parse(body).version;
+                    resolve(latest && isNewer(latest, currentVersion) ? latest : null);
+                }
+                catch {
+                    resolve(null);
+                }
+            });
+        });
+        request.on('timeout', () => {
+            request.destroy();
+            resolve(null);
+        });
+        request.on('error', () => {
+            resolve(null);
+        });
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "sitevision-cli",
-	"version": "0.1.2",
+	"version": "0.3.1-beta.1",
 	"license": "MIT",
 	"bin": {
 		"svc": "dist/cli.js"
@@ -12,23 +12,24 @@
 	"scripts": {
 		"build": "tsc",
 		"dev": "tsc --watch",
-		"test": "prettier --check . && xo && ava"
+		"test": "prettier --check . && xo && ava",
+		"release": "./scripts/publish.sh",
+		"release:beta": "./scripts/publish-beta.sh"
 	},
 	"files": [
 		"dist"
 	],
 	"dependencies": {
+		"@napi-rs/keyring": "^1.3.0",
 		"ink": "^6.6.0",
 		"ink-spinner": "^5.0.0",
 		"meow": "^11.0.0",
-		"react": "^19.2.3",
-		"update-notifier": "^7.0.0"
+		"react": "^19.2.3"
 	},
 	"devDependencies": {
 		"@sindresorhus/tsconfig": "^3.0.1",
 		"@types/node": "^25.0.3",
 		"@types/react": "^19.2.7",
-		"@types/update-notifier": "^6.0.8",
 		"@vdemedes/prettier-config": "^2.0.1",
 		"ava": "^5.2.0",
 		"chalk": "^5.2.0",
@@ -58,4 +59,4 @@
 		}
 	},
 	"prettier": "@vdemedes/prettier-config"
-}
+}

package/readme.md

@@ -12,7 +12,7 @@ However, these scripts have some limitations:
 - **Project Detection** - Automatically detects Sitevision projects
 - **Two Modes** - Interactive menu OR direct command execution
 - **Automatic Setup** - Guided setup for dev properties and signing credentials
-- **Secure Credentials** - Passwords can be entered per-session (not stored on disk)
+- **Secure Credentials** - Passwords live in the OS keychain (macOS Keychain / Windows Credential Manager / Linux libsecret), never on disk
 
 ## Install
 
@@ -117,14 +117,29 @@ Create this file in your project root for deployment configuration:
   "siteName": "YourSite",
   "addonName": "your-addon",
   "username": "your-email@example.com",
-  "password": "",
   "useHTTPForDevDeploy": false,
   "signingUsername": "your-developer-account@example.com",
   "certificateName": "optional-certificate-name"
 }
 ```
 
-**Note:** You can leave `password` empty - the CLI will prompt for it securely at runtime and store it in session memory only.
+### Password storage
+
+Passwords are stored in the OS-native secret store (macOS Keychain, Windows
+Credential Manager, Linux libsecret) under the `sitevision-cli` service —
+never in `.dev_properties.json`. Run `svc` and complete the setup form (or
+enter the password when prompted at deploy/sign time and toggle "save to
+keychain") to populate it.
+
+If an existing `.dev_properties.json` contains a plaintext `password` field,
+the CLI offers to migrate it to the keychain on next launch and strip the
+field from the file. The migration prompt only appears in interactive mode
+(plain `svc`) — if you only ever invoke commands directly (`svc deploy`,
+`svc dev`), run `svc` once to migrate.
+
+For CI / headless use, set `SITEVISION_DEPLOY_PASSWORD` and/or
+`SITEVISION_SIGNING_PASSWORD` — these take precedence over the keychain and
+are never written anywhere.
 
 ### Signing Credentials
 
@@ -132,7 +147,8 @@ Signing credentials are used to sign apps via developer.sitevision.se:
 - `signingUsername` - Your developer.sitevision.se account
 - `certificateName` - Optional, if you have multiple certificates
 
-The signing password is never stored on disk - it's prompted for each session.
+The signing password is prompted on first use, with an option to save it to
+the OS keychain for future runs.
 
 ## License