@pixelbyte-software/pixcode 1.47.1 → 1.47.3

package/scripts/smoke/git-install-update.mjs

@@ -0,0 +1,176 @@
+import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+const serverIndex = fs.readFileSync('server/index.js', 'utf8');
+const modal = fs.readFileSync('src/components/version-upgrade/view/VersionUpgradeModal.tsx', 'utf8');
+const updater = fs.readFileSync('scripts/update-git-install.mjs', 'utf8');
+const updaterPath = path.resolve('scripts/update-git-install.mjs');
+
+assert.match(
+  serverIndex,
+  /update-git-install\.mjs/,
+  'Git install updates should use the safe updater script instead of raw git pull.',
+);
+
+assert.doesNotMatch(
+  serverIndex,
+  /git checkout main && git pull && npm install/,
+  'Server update command should not use the brittle raw git checkout/pull/install chain.',
+);
+
+assert.match(
+  serverIndex,
+  /updateCommandLabel[\s\S]*Pixcode source update/,
+  'Server update stream should describe git installs with product language instead of an internal script command.',
+);
+
+assert.match(
+  modal,
+  /versionUpdate\.pixcodeUpgradeCommand/,
+  'Version modal should show the user-facing Pixcode update command.',
+);
+
+assert.doesNotMatch(
+  modal,
+  /node scripts\/update-git-install\.mjs/,
+  'Version modal should not expose the internal git updater script as manual product guidance.',
+);
+
+assert.match(
+  fs.readFileSync('server/cli.js', 'utf8'),
+  /update-git-install\.mjs[\s\S]*installMode === 'git'[\s\S]*updateGitPackage/,
+  'pixcode update should drive the safe git updater for source installs.',
+);
+
+assert.match(
+  updater,
+  /stash[\s\S]*push[\s\S]*--include-untracked[\s\S]*--message/,
+  'Safe updater should stash dirty tracked and untracked files before updating.',
+);
+
+assert.match(
+  updater,
+  /branch[\s\S]*backupBranch/,
+  'Safe updater should preserve divergent local commits in a backup branch.',
+);
+
+assert.match(
+  updater,
+  /reset[\s\S]*--hard[\s\S]*origin\/main/,
+  'Safe updater should be able to normalize a divergent install checkout after preserving it.',
+);
+
+assert.match(
+  updater,
+  /npm[\s\S]*install[\s\S]*--no-audit[\s\S]*--no-fund/,
+  'Safe updater should reinstall dependencies after updating source files.',
+);
+
+assert.match(
+  updater,
+  /npm[\s\S]*run[\s\S]*build/,
+  'Safe updater should rebuild source installs after updating source files.',
+);
+
+const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'pixcode-git-update-'));
+const origin = path.join(tempRoot, 'origin.git');
+const source = path.join(tempRoot, 'source');
+const install = path.join(tempRoot, 'install');
+
+function run(command, args, cwd) {
+  const result = spawnSync(command, args, {
+    cwd,
+    encoding: 'utf8',
+    env: {
+      ...process.env,
+      GIT_AUTHOR_NAME: 'Pixcode Smoke',
+      GIT_AUTHOR_EMAIL: 'smoke@pixcode.local',
+      GIT_COMMITTER_NAME: 'Pixcode Smoke',
+      GIT_COMMITTER_EMAIL: 'smoke@pixcode.local',
+    },
+  });
+
+  assert.equal(
+    result.status,
+    0,
+    `${command} ${args.join(' ')} failed\nstdout:\n${result.stdout}\nstderr:\n${result.stderr}`,
+  );
+
+  return result.stdout.trim();
+}
+
+function writePackage(version) {
+  fs.writeFileSync(
+    path.join(source, 'package.json'),
+    JSON.stringify({
+      name: 'pixcode-update-smoke',
+      version,
+      scripts: {
+        build: 'node -e "require(\\"node:fs\\").writeFileSync(\\"built.txt\\", \\"built\\")"',
+      },
+    }, null, 2),
+  );
+  fs.writeFileSync(
+    path.join(source, 'package-lock.json'),
+    JSON.stringify({
+      name: 'pixcode-update-smoke',
+      version,
+      lockfileVersion: 3,
+      requires: true,
+      packages: {
+        '': {
+          name: 'pixcode-update-smoke',
+          version,
+        },
+      },
+    }, null, 2),
+  );
+}
+
+fs.mkdirSync(source, { recursive: true });
+run('git', ['init', '--bare', origin], tempRoot);
+run('git', ['init', '-b', 'main'], source);
+writePackage('1.0.0');
+fs.writeFileSync(path.join(source, 'tracked.txt'), 'old\n');
+run('git', ['add', '.'], source);
+run('git', ['commit', '-m', 'initial'], source);
+run('git', ['remote', 'add', 'origin', origin], source);
+run('git', ['push', '-u', 'origin', 'main'], source);
+run('git', ['symbolic-ref', 'HEAD', 'refs/heads/main'], origin);
+run('git', ['clone', origin, install], tempRoot);
+
+writePackage('1.0.1');
+fs.writeFileSync(path.join(source, 'tracked.txt'), 'new\n');
+run('git', ['add', '.'], source);
+run('git', ['commit', '-m', 'update'], source);
+run('git', ['push', 'origin', 'main'], source);
+
+fs.writeFileSync(path.join(install, 'tracked.txt'), 'local dirty change\n');
+fs.writeFileSync(path.join(install, 'untracked.txt'), 'local untracked change\n');
+run(process.execPath, [updaterPath], install);
+
+assert.equal(
+  JSON.parse(fs.readFileSync(path.join(install, 'package.json'), 'utf8')).version,
+  '1.0.1',
+  'Safe updater should fast-forward the install checkout.',
+);
+assert.equal(
+  fs.readFileSync(path.join(install, 'tracked.txt'), 'utf8'),
+  'new\n',
+  'Safe updater should apply the remote tracked file after stashing local edits.',
+);
+assert.match(
+  run('git', ['stash', 'list'], install),
+  /pixcode-auto-update-/,
+  'Safe updater should leave local dirty files recoverable in git stash.',
+);
+assert.equal(
+  fs.readFileSync(path.join(install, 'built.txt'), 'utf8'),
+  'built',
+  'Safe updater should run the repository build after installing dependencies.',
+);
+
+console.log('git install update smoke passed');

package/scripts/smoke/vscode-workbench-polish.mjs

@@ -80,6 +80,12 @@ assert.match(
   'Workbench should request compact composer behavior in the right CLI pane.',
 );
 
+assert.match(
+  workbench,
+  /activeTab === 'chat' && activityPanel === 'projects'/,
+  'Projects activity should stay selected while the center chat tab is active.',
+);
+
 assert.match(chatInterface, /compactComposer\?: boolean/, 'ChatInterface should expose compactComposer for narrow workbench panes.');
 assert.match(chatComposer, /compact\?: boolean/, 'ChatComposer should expose a compact prop.');
 assert.match(chatComposer, /flex-wrap/, 'ChatComposer footer should wrap controls in narrow panes.');

package/scripts/update-git-install.mjs

@@ -0,0 +1,135 @@
+#!/usr/bin/env node
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+
+const repoRoot = process.cwd();
+const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+const stashMessage = `pixcode-auto-update-${timestamp}`;
+const backupBranch = `pixcode-backup-before-update-${timestamp}`;
+
+function log(message) {
+  process.stdout.write(`${message}\n`);
+}
+
+function run(command, args, options = {}) {
+  const {
+    allowFailure = false,
+    collectOutput = false,
+    env = process.env,
+  } = options;
+
+  return new Promise((resolve, reject) => {
+    log(`$ ${[command, ...args].join(' ')}`);
+    const child = spawn(command, args, {
+      cwd: repoRoot,
+      env,
+      shell: false,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    child.stdout?.on('data', (chunk) => {
+      const text = chunk.toString();
+      stdout += text;
+      process.stdout.write(text);
+    });
+
+    child.stderr?.on('data', (chunk) => {
+      const text = chunk.toString();
+      stderr += text;
+      process.stderr.write(text);
+    });
+
+    child.on('error', reject);
+    child.on('close', (code) => {
+      const result = { code, stdout, stderr };
+      if (code === 0 || allowFailure) {
+        resolve(collectOutput ? result : code);
+        return;
+      }
+
+      const error = new Error(`${command} ${args.join(' ')} exited with code ${code}`);
+      error.result = result;
+      reject(error);
+    });
+  });
+}
+
+async function getOutput(command, args, options = {}) {
+  const result = await run(command, args, { ...options, collectOutput: true });
+  return result.stdout.trim();
+}
+
+async function main() {
+  if (!fs.existsSync(path.join(repoRoot, '.git'))) {
+    throw new Error(`Git metadata not found in ${repoRoot}`);
+  }
+
+  log('Pixcode safe git update started.');
+  log(`Repository: ${repoRoot}`);
+
+  await run('git', ['rev-parse', '--is-inside-work-tree']);
+  await run('git', ['fetch', 'origin', 'main']);
+
+  const status = await getOutput('git', ['status', '--porcelain', '--untracked-files=all']);
+  if (status) {
+    log('Local checkout has modified or untracked files.');
+    log(`Saving them to git stash: ${stashMessage}`);
+    await run('git', [
+      '-c',
+      'user.name=Pixcode Updater',
+      '-c',
+      'user.email=updater@pixcode.local',
+      'stash',
+      'push',
+      '--include-untracked',
+      '--message',
+      stashMessage,
+    ]);
+    log('Local changes are preserved in git stash.');
+  } else {
+    log('Working tree is clean.');
+  }
+
+  const checkoutMain = await run('git', ['checkout', 'main'], { allowFailure: true, collectOutput: true });
+  if (checkoutMain.code !== 0) {
+    log('Local main branch checkout failed; recreating main from origin/main.');
+    await run('git', ['checkout', '-B', 'main', 'origin/main']);
+  }
+
+  const isAncestor = await run('git', ['merge-base', '--is-ancestor', 'HEAD', 'origin/main'], {
+    allowFailure: true,
+    collectOutput: true,
+  });
+
+  if (isAncestor.code === 0) {
+    await run('git', ['merge', '--ff-only', 'origin/main']);
+  } else if (isAncestor.code === 1) {
+    log(`Local main has commits that are not on origin/main. Preserving them in branch: ${backupBranch}`);
+    await run('git', ['branch', backupBranch]);
+    await run('git', ['reset', '--hard', 'origin/main']);
+  } else {
+    throw new Error('Could not compare local main with origin/main.');
+  }
+
+  const packageVersion = JSON.parse(fs.readFileSync(path.join(repoRoot, 'package.json'), 'utf8')).version;
+  log(`Repository updated to Pixcode ${packageVersion}.`);
+
+  await run('npm', ['install', '--no-audit', '--no-fund']);
+  const updatedPackageJson = JSON.parse(fs.readFileSync(path.join(repoRoot, 'package.json'), 'utf8'));
+  if (updatedPackageJson.scripts?.build) {
+    log('Building Pixcode source install.');
+    await run('npm', ['run', 'build']);
+  } else {
+    log('No build script found; skipping build.');
+  }
+  log('Pixcode git install update completed.');
+}
+
+main().catch((error) => {
+  process.stderr.write(`Pixcode git install update failed: ${error.message}\n`);
+  process.exit(1);
+});

package/server/cli.js

@@ -249,10 +249,77 @@ async function checkForUpdates(silent = false) {
     }
 }
 
+function runInherited(command, args, options = {}) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            cwd: options.cwd || APP_ROOT,
+            env: options.env || process.env,
+            stdio: 'inherit',
+            shell: false,
+            windowsHide: false,
+        });
+
+        child.on('error', reject);
+        child.on('close', (code) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+
+            reject(new Error(`${command} ${args.join(' ')} exited with code ${code}`));
+        });
+    });
+}
+
+async function maybeRestartDaemonAfterUpdate(options = {}) {
+    if (options.restartDaemon) {
+        if (!hasInstalledDaemonUnit()) {
+            console.log(`${c.warn('[WARN]')} No daemon unit detected; skipping restart.`);
+            return;
+        }
+        console.log(`${c.info('[INFO]')} Restarting daemon service...`);
+        await handleDaemonCommand(['restart', '--mode=system'], {
+            appRoot: APP_ROOT,
+            defaultPort: process.env.SERVER_PORT || process.env.PORT || '3001',
+            color: c,
+        });
+        console.log(`${c.ok('[OK]')} Daemon restart completed.`);
+        return;
+    }
+
+    if (hasInstalledDaemonUnit()) {
+        const restartCommand = buildDaemonCliCommand(
+            { subcommand: 'restart', mode: 'system' },
+            DAEMON_COMMAND_CONTEXT
+        );
+        console.log(`${c.tip('[TIP]')} Daemon unit detected. Restart to apply update: ${c.bright(restartCommand)}`);
+        console.log(`${c.tip('[TIP]')} Or update + restart in one step: ${c.bright('pixcode update --restart-daemon')}`);
+    } else {
+        console.log(`${c.tip('[TIP]')} Restart pixcode to use the new version.`);
+    }
+}
+
+async function updateGitPackage(options = {}) {
+    const gitUpdateScript = path.join(APP_ROOT, 'scripts', 'update-git-install.mjs');
+    if (!fs.existsSync(gitUpdateScript)) {
+        throw new Error(`Git update script was not found: ${gitUpdateScript}`);
+    }
+
+    console.log(`${c.info('[INFO]')} Updating Pixcode source checkout...`);
+    await runInherited(process.execPath, [gitUpdateScript], { cwd: APP_ROOT });
+    console.log(`${c.ok('[OK]')} Source update complete!`);
+    await maybeRestartDaemonAfterUpdate(options);
+}
+
 // Update the package
 async function updatePackage(options = {}) {
     try {
         const { execSync } = await import('child_process');
+        if (installMode === 'git') {
+            await updateGitPackage(options);
+            return;
+        }
+
         console.log(`${c.info('[INFO]')} Checking for updates...`);
 
         const { hasUpdate, latestVersion, currentVersion } = await checkForUpdates(true);
@@ -265,32 +332,13 @@ async function updatePackage(options = {}) {
         console.log(`${c.info('[INFO]')} Updating from ${currentVersion} to ${latestVersion}...`);
         execSync('npm update -g @pixelbyte-software/pixcode', { stdio: 'inherit' });
         console.log(`${c.ok('[OK]')} Update complete!`);
-
-        if (options.restartDaemon) {
-            if (!hasInstalledDaemonUnit()) {
-                console.log(`${c.warn('[WARN]')} No daemon unit detected; skipping restart.`);
-                return;
-            }
-            console.log(`${c.info('[INFO]')} Restarting daemon service...`);
-            await handleDaemonCommand(['restart', '--mode=system'], {
-                appRoot: APP_ROOT,
-                defaultPort: process.env.SERVER_PORT || process.env.PORT || '3001',
-                color: c,
-            });
-            console.log(`${c.ok('[OK]')} Daemon restart completed.`);
-        } else if (hasInstalledDaemonUnit()) {
-            const restartCommand = buildDaemonCliCommand(
-                { subcommand: 'restart', mode: 'system' },
-                DAEMON_COMMAND_CONTEXT
-            );
-            console.log(`${c.tip('[TIP]')} Daemon unit detected. Restart to apply update: ${c.bright(restartCommand)}`);
-            console.log(`${c.tip('[TIP]')} Or update + restart in one step: ${c.bright('pixcode update --restart-daemon')}`);
-        } else {
-            console.log(`${c.tip('[TIP]')} Restart pixcode to use the new version.`);
-        }
+        await maybeRestartDaemonAfterUpdate(options);
     } catch (e) {
         console.error(`${c.error('[ERROR]')} Update failed: ${e.message}`);
-        console.log(`${c.tip('[TIP]')} Try running manually: npm update -g @pixelbyte-software/pixcode`);
+        const fallbackCommand = installMode === 'git'
+            ? 'pixcode update --restart-daemon'
+            : 'npm update -g @pixelbyte-software/pixcode';
+        console.log(`${c.tip('[TIP]')} Try running manually: ${fallbackCommand}`);
     }
 }
 

package/server/index.js

@@ -482,19 +482,27 @@ app.use(express.static(path.join(APP_ROOT, 'public'), {
 //      npm tarball, extracts it to the writable runtime dir, and triggers
 //      a server restart so the Electron wrapper respawns with new code.
 //      ~4 MB download, ~10 s; no npm/git/shell required on the host.
-//   2. installMode === 'git' → `git pull && npm install` in-place.
+//   2. installMode === 'git' → safe git updater script. It stashes dirty
+//      checkout state before pulling so source installs do not fail on local
+//      modified files left by older releases or manual edits.
 //   3. fallback → `npm install -g …` (classic npm-distributed install).
 app.post('/api/system/update', authenticateToken, async (req, res) => {
     const projectRoot = APP_ROOT;
     console.log('Starting system update from directory:', projectRoot);
 
     const runtimeDir = process.env.PIXCODE_RUNTIME_DIR || null;
+    const gitUpdateScript = path.join(projectRoot, 'scripts', 'update-git-install.mjs');
 
     const updateCommand = IS_PLATFORM
         ? 'npm run update:platform'
         : installMode === 'git'
-            ? 'git checkout main && git pull && npm install'
+            ? `${JSON.stringify(process.execPath)} ${JSON.stringify(gitUpdateScript)}`
             : 'npm install -g @pixelbyte-software/pixcode@latest';
+    const updateCommandLabel = IS_PLATFORM
+        ? 'Pixcode platform update'
+        : installMode === 'git'
+            ? 'Pixcode source update'
+            : 'pixcode update';
 
     const updateCwd = IS_PLATFORM || installMode === 'git'
         ? projectRoot
@@ -738,8 +746,9 @@ app.post('/api/system/update', authenticateToken, async (req, res) => {
     // Short-circuit for "already on latest" in the npm-global path so
     // users don't accidentally crash their own daemon by clicking Update
     // while already up to date. The runtime-dir branch above already has
-    // this guard (line ~504); replicate it for npm mode. Git mode skips
-    // this since `git pull` is harmless when already up to date.
+    // this guard (line ~504); replicate it for npm mode. Git mode still
+    // runs because users may be on the latest package version but behind
+    // the source branch or have a dirty checkout that needs normalization.
     if (!IS_PLATFORM && installMode === 'npm') {
         try {
             send('log', { stream: 'meta', chunk: 'Querying registry for latest version…\n' });
@@ -766,7 +775,7 @@ app.post('/api/system/update', authenticateToken, async (req, res) => {
         }
     }
 
-    send('log', { stream: 'meta', chunk: `Running: ${updateCommand}\n` });
+    send('log', { stream: 'meta', chunk: `Running: ${updateCommandLabel}\n` });
 
     // Cross-platform shell invocation. `detached: true` + `unref()` below
     // means the install child survives if this server process gets killed