@algochad/archcoder 2.0.2

package/server/lib/installer/desktop.js

@@ -0,0 +1,289 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { spawn } from 'child_process';
+import { getInstallDir } from './platform.js';
+
+const APP_NAME = 'ArchCoder';
+const APP_ID = 'ai.opencode.archcoder';
+
+async function installDesktopIntegration(artifactPath, version, options) {
+  const platform = process.platform;
+
+  if (platform === 'linux') {
+    return installLinuxIntegration(artifactPath, version, options);
+  } else if (platform === 'darwin') {
+    return installMacOSIntegration(artifactPath, version, options);
+  } else if (platform === 'win32') {
+    return installWindowsIntegration(artifactPath, version, options);
+  }
+
+  throw new Error(`Unsupported platform: ${platform}`);
+}
+
+async function uninstallDesktopIntegration(options) {
+  const platform = process.platform;
+
+  if (platform === 'linux') {
+    return uninstallLinuxIntegration(options);
+  } else if (platform === 'darwin') {
+    return uninstallMacOSIntegration(options);
+  } else if (platform === 'win32') {
+    return uninstallWindowsIntegration(options);
+  }
+
+  throw new Error(`Unsupported platform: ${platform}`);
+}
+
+async function getDesktopStatus() {
+  const platform = process.platform;
+  const installDir = getInstallDir();
+  const result = {
+    desktopEntry: null,
+    appPath: null,
+    shortcuts: [],
+  };
+
+  if (platform === 'linux') {
+    const desktopFile = path.join(os.homedir(), '.local', 'share', 'applications', `${APP_NAME.toLowerCase()}.desktop`);
+    if (fs.existsSync(desktopFile)) {
+      result.desktopEntry = desktopFile;
+    }
+    const appImagePath = path.join(installDir, 'ArchCoder.AppImage');
+    if (fs.existsSync(appImagePath)) {
+      result.appPath = appImagePath;
+    }
+  } else if (platform === 'darwin') {
+    const appBundlePath = path.join('/Applications', `${APP_NAME}.app`);
+    if (fs.existsSync(appBundlePath)) {
+      result.appPath = appBundlePath;
+    }
+  } else if (platform === 'win32') {
+    const appExePath = path.join(installDir, `${APP_NAME}.exe`);
+    if (fs.existsSync(appExePath)) {
+      result.appPath = appExePath;
+    }
+    const startMenuDir = path.join(process.env.APPDATA || '', 'Microsoft', 'Windows', 'Start Menu', 'Programs', APP_NAME);
+    if (fs.existsSync(startMenuDir)) {
+      result.shortcuts.push(startMenuDir);
+    }
+  }
+
+  return result;
+}
+
+async function runCommand(command, args, options = {}) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn(command, args, {
+      ...options,
+      stdio: options.silent ? 'pipe' : 'inherit',
+    });
+    
+    let stdout = '';
+    let stderr = '';
+    
+    if (options.silent) {
+      proc.stdout?.on('data', data => stdout += data);
+      proc.stderr?.on('data', data => stderr += data);
+    }
+    
+    proc.on('close', code => {
+      if (code === 0) {
+        resolve({ stdout, stderr });
+      } else {
+        reject(new Error(`${command} exited with code ${code}: ${stderr}`));
+      }
+    });
+    proc.on('error', reject);
+  });
+}
+
+async function installLinuxIntegration(artifactPath, version, options) {
+  const installDir = getInstallDir();
+  fs.mkdirSync(installDir, { recursive: true });
+  
+  const appImagePath = path.join(installDir, 'ArchCoder.AppImage');
+  
+  if (fs.existsSync(appImagePath)) {
+    fs.unlinkSync(appImagePath);
+  }
+  fs.cpSync(artifactPath, appImagePath);
+  fs.chmodSync(appImagePath, 0o755);
+  
+  const applicationsDir = path.join(os.homedir(), '.local', 'share', 'applications');
+  fs.mkdirSync(applicationsDir, { recursive: true });
+  
+  const desktopContent = `[Desktop Entry]
+Version=1.0
+Name=${APP_NAME}
+Comment=AI-powered coding assistant
+Exec=${appImagePath}
+Icon=${APP_NAME.toLowerCase()}
+Terminal=false
+Type=Application
+Categories=Development;IDE;
+StartupNotify=true
+StartupWMClass=${APP_NAME}
+`;
+
+  const desktopFile = path.join(applicationsDir, `${APP_NAME.toLowerCase()}.desktop`);
+  fs.writeFileSync(desktopFile, desktopContent);
+  
+  await installLinuxIcon(artifactPath, options);
+  
+  return { appPath: appImagePath, desktopFile };
+}
+
+async function installLinuxIcon(artifactPath, options) {
+  const iconsDir = path.join(os.homedir(), '.local', 'share', 'icons', 'hicolor');
+  const iconSizes = ['16x16', '32x32', '48x48', '64x64', '128x128', '256x256', '512x512'];
+  
+  for (const size of iconSizes) {
+    const sizeDir = path.join(iconsDir, size, 'apps');
+    fs.mkdirSync(sizeDir, { recursive: true });
+  }
+  
+  const buildDir = path.join(path.dirname(artifactPath), '..', 'build');
+  if (fs.existsSync(buildDir)) {
+    for (const size of iconSizes) {
+      const srcIcon = path.join(buildDir, `${size}.png`);
+      if (fs.existsSync(srcIcon)) {
+        const destIcon = path.join(iconsDir, size, 'apps', `${APP_NAME.toLowerCase()}.png`);
+        fs.cpSync(srcIcon, destIcon);
+      }
+    }
+  }
+}
+
+async function uninstallLinuxIntegration(options) {
+  const installDir = getInstallDir();
+  const applicationsDir = path.join(os.homedir(), '.local', 'share', 'applications');
+  
+  const desktopFile = path.join(applicationsDir, `${APP_NAME.toLowerCase()}.desktop`);
+  if (fs.existsSync(desktopFile)) {
+    fs.unlinkSync(desktopFile);
+  }
+  
+  if (fs.existsSync(installDir)) {
+    fs.rmSync(installDir, { recursive: true, force: true });
+  }
+  
+  const iconsDir = path.join(os.homedir(), '.local', 'share', 'icons', 'hicolor');
+  const iconSizes = ['16x16', '32x32', '48x48', '64x64', '128x128', '256x256', '512x512'];
+  for (const size of iconSizes) {
+    const iconFile = path.join(iconsDir, size, 'apps', `${APP_NAME.toLowerCase()}.png`);
+    if (fs.existsSync(iconFile)) {
+      fs.unlinkSync(iconFile);
+    }
+  }
+}
+
+async function installMacOSIntegration(artifactPath, version, options) {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'archcoder-dmg-'));
+  const dmgPath = path.join(tempDir, `${APP_NAME}.dmg`);
+  const mountPoint = path.join(tempDir, 'mount');
+  
+  fs.cpSync(artifactPath, dmgPath);
+  
+  fs.mkdirSync(mountPoint, { recursive: true });
+  
+  try {
+    await runCommand('hdiutil', ['attach', dmgPath, '-mountpoint', mountPoint, '-nobrowse']);
+    
+    const sourceApp = path.join(mountPoint, `${APP_NAME}.app`);
+    const destApp = path.join('/Applications', `${APP_NAME}.app`);
+    
+    if (fs.existsSync(destApp)) {
+      fs.rmSync(destApp, { recursive: true, force: true });
+    }
+    fs.cpSync(sourceApp, destApp);
+    
+    await runCommand('hdiutil', ['detach', mountPoint]);
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+  
+  return { appPath: `/Applications/${APP_NAME}.app` };
+}
+
+async function uninstallMacOSIntegration(options) {
+  const appPath = path.join('/Applications', `${APP_NAME}.app`);
+  
+  if (fs.existsSync(appPath)) {
+    fs.rmSync(appPath, { recursive: true, force: true });
+  }
+}
+
+async function installWindowsIntegration(artifactPath, version, options) {
+  const installDir = getInstallDir();
+  fs.mkdirSync(installDir, { recursive: true });
+  
+  const exePath = path.join(installDir, `${APP_NAME}.exe`);
+  
+  if (fs.existsSync(exePath)) {
+    fs.unlinkSync(exePath);
+  }
+  fs.cpSync(artifactPath, exePath);
+  
+  const appData = process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming');
+  const startMenuDir = path.join(appData, 'Microsoft', 'Windows', 'Start Menu', 'Programs', APP_NAME);
+  fs.mkdirSync(startMenuDir, { recursive: true });
+  
+  const shortcutPath = path.join(startMenuDir, `${APP_NAME}.lnk`);
+  
+  try {
+    const { shell } = await import('electron');
+    await shell.writeShortcutLink(shortcutPath, {
+      target: exePath,
+      cwd: installDir,
+      description: `${APP_NAME} - AI-powered coding assistant`,
+    });
+  } catch {
+    try {
+      const { default: createShortcut } = await import('windows-shortcuts');
+      await new Promise((resolve, reject) => {
+        createShortcut(shortcutPath, {
+          target: exePath,
+          cwd: installDir,
+          description: `${APP_NAME} - AI-powered coding assistant`,
+        }, err => {
+          if (err) reject(err);
+          else resolve();
+        });
+      });
+    } catch {
+      const batContent = `@echo off
+start "" "${exePath}"
+`;
+      const batPath = path.join(startMenuDir, `${APP_NAME}.bat`);
+      fs.writeFileSync(batPath, batContent);
+    }
+  }
+  
+  return { appPath: exePath, startMenuDir };
+}
+
+async function uninstallWindowsIntegration(options) {
+  const installDir = getInstallDir();
+  const appData = process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming');
+  const startMenuDir = path.join(appData, 'Microsoft', 'Windows', 'Start Menu', 'Programs', APP_NAME);
+  
+  if (fs.existsSync(startMenuDir)) {
+    fs.rmSync(startMenuDir, { recursive: true, force: true });
+  }
+  
+  if (fs.existsSync(installDir)) {
+    fs.rmSync(installDir, { recursive: true, force: true });
+  }
+}
+
+async function checkLinuxDependencies(options) {
+  return [];
+}
+
+export {
+  installDesktopIntegration,
+  uninstallDesktopIntegration,
+  getDesktopStatus,
+  checkLinuxDependencies,
+};

package/server/lib/installer/download.js

@@ -0,0 +1,208 @@
+import fs from 'fs';
+import path from 'path';
+import crypto from 'crypto';
+import { spawn } from 'child_process';
+import { S3Client, GetObjectCommand } from '@aws-sdk/client-s3';
+import { getElectronArtifactName, getCacheDir } from './platform.js';
+
+const MAX_RETRIES = 3;
+const RETRY_DELAYS = [1000, 2000, 4000];
+
+const S3_CONFIG = {
+  endpoint: process.env.ARCHCODER_S3_ENDPOINT || 'https://minio-service.archlast.com',
+  bucket: process.env.ARCHCODER_S3_BUCKET || 'archcoder-releases',
+  region: process.env.ARCHCODER_S3_REGION || 'auto',
+  accessKeyId: process.env.ARCHCODER_S3_ACCESS_KEY || 'z7nBQ7myyoTgRi3C',
+  secretAccessKey: process.env.ARCHCODER_S3_SECRET_KEY || 'Yjcbc2yVGmycJWeWZrqOEN5ZSaFPYo68',
+};
+
+function getS3Client() {
+  return new S3Client({
+    endpoint: S3_CONFIG.endpoint,
+    region: S3_CONFIG.region,
+    credentials: S3_CONFIG.accessKeyId && S3_CONFIG.secretAccessKey ? {
+      accessKeyId: S3_CONFIG.accessKeyId,
+      secretAccessKey: S3_CONFIG.secretAccessKey,
+    } : undefined,
+    forcePathStyle: true,
+  });
+}
+
+async function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+function computeSHA256(filePath) {
+  return new Promise((resolve, reject) => {
+    const hash = crypto.createHash('sha256');
+    const stream = fs.createReadStream(filePath);
+    
+    stream.on('data', chunk => hash.update(chunk));
+    stream.on('end', () => resolve(hash.digest('hex')));
+    stream.on('error', reject);
+  });
+}
+
+async function getLatestVersion() {
+  const client = getS3Client();
+
+  try {
+    const command = new GetObjectCommand({
+      Bucket: S3_CONFIG.bucket,
+      Key: 'releases/latest.json',
+    });
+
+    const response = await client.send(command);
+    const body = await streamToString(response.Body);
+    const data = JSON.parse(body);
+
+    return data.version;
+  } catch (error) {
+    if (error.name === 'NoSuchKey' || error.$metadata?.httpStatusCode === 404) {
+      throw new Error('No releases found. Please check if binaries have been published.');
+    }
+    throw error;
+  }
+}
+
+async function streamToString(stream) {
+  const chunks = [];
+  for await (const chunk of stream) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString('utf-8');
+}
+
+async function downloadFromS3(key, destPath, onProgress, options = {}) {
+  const client = getS3Client();
+
+  const command = new GetObjectCommand({
+    Bucket: S3_CONFIG.bucket,
+    Key: key,
+  });
+
+  let lastError;
+
+  for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+    try {
+      const response = await client.send(command);
+
+      if (!response.Body) {
+        throw new Error('No response body from S3');
+      }
+
+      const contentLength = response.ContentLength || 0;
+      let downloaded = 0;
+
+      fs.mkdirSync(path.dirname(destPath), { recursive: true });
+
+      const fileStream = fs.createWriteStream(destPath);
+
+      for await (const chunk of response.Body) {
+        fileStream.write(chunk);
+        downloaded += chunk.length;
+
+        if (onProgress && contentLength > 0) {
+          const progress = Math.round((downloaded / contentLength) * 100);
+          onProgress(progress);
+        }
+      }
+
+      fileStream.end();
+
+      await new Promise((resolve, reject) => {
+        fileStream.on('finish', resolve);
+        fileStream.on('error', reject);
+      });
+
+      return;
+    } catch (error) {
+      lastError = error;
+
+      if (error.name === 'NoSuchKey' || error.$metadata?.httpStatusCode === 404) {
+        throw new Error(`Desktop binary not found: ${key}\n` +
+          `S3 bucket: ${S3_CONFIG.bucket}\n` +
+          `Hint: Make sure Electron binaries have been built and uploaded to S3`);
+      }
+
+      if (attempt < MAX_RETRIES) {
+        await sleep(RETRY_DELAYS[attempt]);
+      }
+    }
+  }
+
+  throw lastError;
+}
+
+async function getBinaryChecksum(version, archiveName) {
+  try {
+    const client = getS3Client();
+
+    const command = new GetObjectCommand({
+      Bucket: S3_CONFIG.bucket,
+      Key: `releases/v${version}/${archiveName}.sha256`,
+    });
+
+    const response = await client.send(command);
+    const body = await streamToString(response.Body);
+
+    return body.trim().split(/\s+/)[0];
+  } catch {
+    return null;
+  }
+}
+
+async function downloadBinary({ version, target, quiet, onProgress, options }) {
+  const artifactName = getElectronArtifactName(version, target);
+  
+  let actualVersion = version;
+  if (version === 'latest' || !version) {
+    actualVersion = await getLatestVersion();
+  }
+  
+  const s3Key = `releases/v${actualVersion}/${artifactName}`;
+  
+  const cacheDir = getCacheDir();
+  const destPath = path.join(cacheDir, actualVersion, artifactName);
+  
+  if (fs.existsSync(destPath)) {
+    if (!quiet && shouldRenderHumanOutput(options)) {
+      console.log(`Using cached artifact: ${destPath}`);
+    }
+    return destPath;
+  }
+  
+  fs.mkdirSync(path.dirname(destPath), { recursive: true });
+  
+  await downloadFromS3(s3Key, destPath, onProgress, options);
+  
+  const expectedChecksum = await getBinaryChecksum(actualVersion, artifactName);
+  
+  if (expectedChecksum) {
+    const actualChecksum = await computeSHA256(destPath);
+    
+    if (expectedChecksum !== actualChecksum) {
+      fs.unlinkSync(destPath);
+      throw new Error(`Checksum verification failed. Expected ${expectedChecksum}, got ${actualChecksum}`);
+    }
+  }
+  
+  const isLinux = target.includes('linux');
+  if (isLinux) {
+    fs.chmodSync(destPath, 0o755);
+  }
+  
+  return destPath;
+}
+
+function shouldRenderHumanOutput(options) {
+  return !options?.json && !options?.quiet;
+}
+
+export {
+  downloadBinary,
+  computeSHA256,
+  getLatestVersion,
+  getS3Client,
+  S3_CONFIG,
+};

package/server/lib/installer/index.js

@@ -0,0 +1,45 @@
+import {
+  getDataDir,
+  getPlatformTarget,
+  getElectronArtifactName,
+  getBinaryName,
+  getBinaryPath,
+  getCacheDir,
+  getVersionFilePath,
+  getInstallDir,
+} from './platform.js';
+
+import {
+  downloadBinary,
+  computeSHA256,
+  getLatestVersion,
+  getS3Client,
+  S3_CONFIG,
+} from './download.js';
+
+import {
+  installDesktopIntegration,
+  uninstallDesktopIntegration,
+  getDesktopStatus,
+  checkLinuxDependencies,
+} from './desktop.js';
+
+export {
+  getDataDir,
+  getPlatformTarget,
+  getElectronArtifactName,
+  getBinaryName,
+  getBinaryPath,
+  getCacheDir,
+  getVersionFilePath,
+  getInstallDir,
+  downloadBinary,
+  computeSHA256,
+  getLatestVersion,
+  getS3Client,
+  S3_CONFIG,
+  installDesktopIntegration,
+  uninstallDesktopIntegration,
+  getDesktopStatus,
+  checkLinuxDependencies,
+};

package/server/lib/installer/platform.js

@@ -0,0 +1,100 @@
+import os from 'os';
+import path from 'path';
+
+function getDataDir() {
+  return process.env.ARCHCODER_DATA_DIR || path.join(os.homedir(), '.config', 'archcoder');
+}
+
+function getPlatformTarget() {
+  const platform = process.platform;
+  const arch = process.arch;
+
+  const platformMap = {
+    darwin: {
+      arm64: 'arm64-darwin',
+      x64: 'x64-darwin',
+    },
+    linux: {
+      arm64: 'arm64-linux',
+      x64: 'x64-linux',
+    },
+    win32: {
+      x64: 'x64-windows',
+      arm64: 'arm64-windows',
+    },
+  };
+
+  const target = platformMap[platform]?.[arch];
+  
+  if (!target) {
+    throw new Error(`Unsupported platform: ${platform} ${arch}`);
+  }
+
+  return target;
+}
+
+function getElectronArtifactName(version, target) {
+  const isWindows = target.includes('windows');
+  const isMac = target.includes('darwin');
+  const isLinux = target.includes('linux');
+  const isArm = target.includes('arm64');
+
+  if (isWindows) {
+    return `ArchCoder-${version}-x64.exe`;
+  }
+  
+  if (isMac) {
+    const arch = isArm ? 'arm64' : 'x64';
+    return `ArchCoder-${version}-${arch}.dmg`;
+  }
+  
+  if (isLinux) {
+    const arch = isArm ? 'arm64' : 'x86_64';
+    return `ArchCoder-${version}-${arch}.AppImage`;
+  }
+  
+  throw new Error(`Unknown target: ${target}`);
+}
+
+function getBinaryName(version, target) {
+  const isWindows = target.includes('windows');
+  const ext = isWindows ? '.exe' : '';
+  return `archcoder-server-${target}${ext}`;
+}
+
+function getBinaryPath(version) {
+  const target = getPlatformTarget();
+  const binaryName = getBinaryName(version, target);
+  return path.join(getDataDir(), 'binaries', binaryName);
+}
+
+function getCacheDir() {
+  return path.join(getDataDir(), 'cache', 'binaries');
+}
+
+function getVersionFilePath() {
+  return path.join(getDataDir(), 'binaries', '.version');
+}
+
+function getInstallDir() {
+  const platform = process.platform;
+  
+  if (platform === 'darwin') {
+    return path.join(os.homedir(), '.local', 'share', 'archcoder');
+  } else if (platform === 'win32') {
+    return path.join(process.env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local'), 'ArchCoder');
+  } else {
+    return path.join(os.homedir(), '.local', 'share', 'archcoder');
+  }
+}
+
+export {
+  getDataDir,
+  getPlatformTarget,
+  getElectronArtifactName,
+  getBinaryName,
+  getBinaryPath,
+  getCacheDir,
+  getVersionFilePath,
+  getInstallDir,
+};

package/server/lib/notifications/DOCUMENTATION.md

@@ -0,0 +1,61 @@
+# Notifications Module Documentation
+
+## Purpose
+This module provides notification message preparation utilities for the web server runtime, including text truncation and optional message summarization for system notifications.
+
+## Entrypoints and structure
+- `packages/web/server/lib/notifications/index.js`: public entrypoint imported by `packages/web/server/index.js`.
+- `packages/web/server/lib/notifications/message.js`: helper implementation module.
+- `packages/web/server/lib/notifications/message.test.js`: unit tests for notification message helpers.
+
+## Public exports
+
+### Notifications API (re-exported from message.js)
+- `truncateNotificationText(text, maxLength)`: Truncates text to specified max length, appending `...` if truncated.
+- `prepareNotificationLastMessage({ message, settings, summarize })`: Prepares the last message for notification display, with optional summarization support.
+
+## Constants
+
+### Default values
+- `DEFAULT_NOTIFICATION_MESSAGE_MAX_LENGTH`: 250 (default max length for notification text).
+- `DEFAULT_NOTIFICATION_SUMMARY_THRESHOLD`: 200 (minimum message length to trigger summarization).
+- `DEFAULT_NOTIFICATION_SUMMARY_LENGTH`: 100 (target length for summarized messages).
+
+## Settings object format
+
+The `settings` parameter for `prepareNotificationLastMessage` supports:
+- `summarizeLastMessage` (boolean): Whether to enable summarization for long messages.
+- `summaryThreshold` (number): Minimum message length to trigger summarization (default: 200).
+- `summaryLength` (number): Target length for summarized messages (default: 100).
+- `maxLastMessageLength` (number): Maximum length for the final notification text (default: 250).
+
+## Response contracts
+
+### `truncateNotificationText`
+- Returns empty string for non-string input.
+- Returns original text if under max length.
+- Returns `${text.slice(0, maxLength)}...` for truncated text.
+
+### `prepareNotificationLastMessage`
+- Returns empty string for empty/null message.
+- Returns truncated original message if summarization disabled, message under threshold, or summarization fails.
+- Returns truncated summary if summarization succeeds and returns non-empty string.
+- Always applies `maxLastMessageLength` truncation to final result.
+
+## Notes for contributors
+
+### Adding new notification helpers
+1. Add new helper functions to `packages/web/server/lib/notifications/message.js`.
+2. Export functions that are intended for public use.
+3. Follow existing patterns for input validation (e.g., type checking for strings).
+4. Use `resolvePositiveNumber` for numeric parameters with fallbacks to maintain safe defaults.
+5. Add corresponding unit tests in `packages/web/server/lib/notifications/message.test.js`.
+
+### Error handling
+- `prepareNotificationLastMessage` catches summarization errors and falls back to original message.
+- Invalid numeric parameters default to safe fallback values.
+- Non-string inputs are handled gracefully (return empty string).
+
+### Testing
+- Run `bun run type-check`, `bun run lint`, and `bun run build` before finalizing changes.
+- Unit tests should cover truncation behavior, summarization success/failure, and edge cases (empty strings, invalid inputs).

package/server/lib/notifications/index.js

@@ -0,0 +1 @@
+export { truncateNotificationText, prepareNotificationLastMessage } from './message.js';