@pixelbyte-software/pixcode 1.47.1 → 1.47.2

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

@@ -0,0 +1,141 @@
+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(
+  modal,
+  /node scripts\/update-git-install\.mjs/,
+  'Version modal should show the safe git updater command.',
+);
+
+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.',
+);
+
+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 }, 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.',
+);
+
+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,128 @@
+#!/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']);
+  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/index.js

@@ -482,18 +482,21 @@ 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 updateCwd = IS_PLATFORM || installMode === 'git'
@@ -738,8 +741,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' });