atris 2.6.0 → 2.6.2

package/commands/pull.js

@@ -7,12 +7,13 @@ const { loadConfig } = require('../utils/config');
 const { getLogPath } = require('../lib/file-ops');
 const { parseJournalSections, mergeSections, reconstructJournal } = require('../lib/journal');
 const { loadBusinesses } = require('./business');
+const { loadManifest, saveManifest, computeFileHash, buildManifest, computeLocalHashes, threeWayCompare } = require('../lib/manifest');
 
 async function pullAtris() {
   const arg = process.argv[3];
 
   // If a business name is given, do a business pull
-  if (arg && arg !== '--help') {
+  if (arg && arg !== '--help' && !arg.startsWith('--')) {
     return pullBusiness(arg);
   }
 
@@ -77,13 +78,31 @@ async function pullBusiness(slug) {
     process.exit(1);
   }
 
+  const force = process.argv.includes('--force');
+
+  // Parse --only flag: comma-separated directory prefixes to filter
+  const onlyArg = process.argv.find(a => a.startsWith('--only='));
+  const onlyPrefixes = onlyArg
+    ? onlyArg.slice('--only='.length).split(',').map(p => {
+        // Normalize: strip leading slash, ensure trailing slash for dirs
+        let norm = p.replace(/^\//, '');
+        if (norm && !norm.endsWith('/') && !norm.includes('.')) norm += '/';
+        return norm;
+      }).filter(Boolean)
+    : null;
+
+  // Parse --timeout flag: override default 120s timeout
+  const timeoutArg = process.argv.find(a => a.startsWith('--timeout='));
+  const timeoutMs = timeoutArg
+    ? parseInt(timeoutArg.slice('--timeout='.length), 10) * 1000
+    : 120000;
+
   // Determine output directory
   const intoIdx = process.argv.indexOf('--into');
   let outputDir;
   if (intoIdx !== -1 && process.argv[intoIdx + 1]) {
     outputDir = path.resolve(process.argv[intoIdx + 1]);
   } else {
-    // Default: atris/{slug}/ in current directory, or just {slug}/ if no atris/ folder
     const atrisDir = path.join(process.cwd(), 'atris');
     if (fs.existsSync(atrisDir)) {
       outputDir = path.join(atrisDir, slug);
@@ -92,21 +111,23 @@ async function pullBusiness(slug) {
     }
   }
 
-  // Resolve business ID — check local config first, then API
-  let businessId, workspaceId, businessName;
+  // Resolve business ID — always refresh from API to avoid stale workspace_id
+  let businessId, workspaceId, businessName, resolvedSlug;
   const businesses = loadBusinesses();
 
-  if (businesses[slug]) {
-    businessId = businesses[slug].business_id;
-    workspaceId = businesses[slug].workspace_id;
-    businessName = businesses[slug].name || slug;
-  } else {
-    // Try to find by slug via API
-    const listResult = await apiRequestJson('/businesses/', { method: 'GET', token: creds.token });
-    if (!listResult.ok) {
+  const listResult = await apiRequestJson('/businesses/', { method: 'GET', token: creds.token });
+  if (!listResult.ok) {
+    // Fall back to local cache if API fails
+    if (businesses[slug]) {
+      businessId = businesses[slug].business_id;
+      workspaceId = businesses[slug].workspace_id;
+      businessName = businesses[slug].name || slug;
+      resolvedSlug = businesses[slug].slug || slug;
+    } else {
       console.error(`Failed to fetch businesses: ${listResult.errorMessage || listResult.status}`);
       process.exit(1);
     }
+  } else {
     const match = (listResult.data || []).find(
       b => b.slug === slug || b.name.toLowerCase() === slug.toLowerCase()
     );
@@ -117,8 +138,9 @@ async function pullBusiness(slug) {
     businessId = match.id;
     workspaceId = match.workspace_id;
     businessName = match.name;
+    resolvedSlug = match.slug;
 
-    // Auto-save for next time
+    // Update local cache
     businesses[slug] = {
       business_id: businessId,
       workspace_id: workspaceId,
@@ -135,74 +157,178 @@ async function pullBusiness(slug) {
     process.exit(1);
   }
 
+  // Load manifest (last sync state)
+  const manifest = loadManifest(resolvedSlug || slug);
+  const timeSince = manifest ? _timeSince(manifest.last_sync) : null;
+
   console.log('');
-  console.log(`Pulling ${businessName}...`);
+  console.log(`Pulling ${businessName}...` + (timeSince ? `  (last synced ${timeSince})` : ''));
+  console.log('  Fetching workspace...');
 
-  // Snapshot — one API call gets everything
+  // Get remote snapshot (large workspaces can take 60s+)
   const result = await apiRequestJson(
     `/businesses/${businessId}/workspaces/${workspaceId}/snapshot?include_content=true`,
-    { method: 'GET', token: creds.token }
+    { method: 'GET', token: creds.token, timeoutMs }
   );
 
   if (!result.ok) {
-    const msg = result.errorMessage || `HTTP ${result.status}`;
-    if (result.status === 409) {
-      console.error(`\nComputer is sleeping. Wake it first, then pull again.`);
+    const msg = result.errorMessage || result.error || `HTTP ${result.status}`;
+    if (result.status === 0 || (typeof msg === 'string' && msg.toLowerCase().includes('timeout'))) {
+      console.error(`\n  Workspace is taking too long to respond. Try: atris pull ${slug} --timeout=120`);
+    } else if (result.status === 409) {
+      console.error(`\n  Computer is sleeping. Wake it first, then pull again.`);
     } else if (result.status === 403) {
-      console.error(`\nAccess denied. You're not a member of "${slug}".`);
+      console.error(`\n  Access denied. You're not a member of "${slug}".`);
     } else if (result.status === 404) {
-      console.error(`\nBusiness "${slug}" not found.`);
+      console.error(`\n  Business "${slug}" not found.`);
     } else {
-      console.error(`\nPull failed: ${msg}`);
+      console.error(`\n  Pull failed: ${msg}`);
     }
     process.exit(1);
   }
 
-  const files = result.data.files || [];
+  let files = result.data.files || [];
   if (files.length === 0) {
     console.log('  Workspace is empty.');
     return;
   }
 
-  // Write files to local directory
-  let written = 0;
-  let skipped = 0;
+  console.log(`  Processing ${files.length} files...`);
 
-  for (const file of files) {
-    if (!file.path || file.content === null || file.content === undefined) {
-      skipped++;
-      continue;
-    }
-    if (file.binary) {
-      skipped++;
-      continue;
+  // Apply --only filter if specified
+  if (onlyPrefixes) {
+    files = files.filter(file => {
+      if (!file.path) return false;
+      const rel = file.path.replace(/^\//, '');
+      return onlyPrefixes.some(prefix => rel.startsWith(prefix));
+    });
+    if (files.length === 0) {
+      console.log(`  No files matched --only filter: ${onlyPrefixes.join(', ')}`);
+      return;
     }
+    console.log(`  Filtered to ${files.length} files matching: ${onlyPrefixes.join(', ')}`);
+  }
+
+  // Build remote file map {path: {hash, size, content}}
+  const remoteFiles = {};
+  const remoteContent = {};
+  for (const file of files) {
+    if (!file.path || file.binary || file.content === null || file.content === undefined) continue;
+    // Skip empty files (deleted files that were blanked out)
+    if (file.content === '') continue;
+    // Compute hash from content bytes (matches computeLocalHashes raw byte hashing)
+    const crypto = require('crypto');
+    const rawBytes = Buffer.from(file.content, 'utf-8');
+    remoteFiles[file.path] = { hash: crypto.createHash('sha256').update(rawBytes).digest('hex'), size: rawBytes.length };
+    remoteContent[file.path] = file.content;
+  }
+
+  // Compute local file hashes
+  const localFiles = fs.existsSync(outputDir) ? computeLocalHashes(outputDir) : {};
+
+  // Three-way compare
+  const baseFiles = (manifest && manifest.files) ? manifest.files : {};
+  const diff = threeWayCompare(localFiles, remoteFiles, manifest);
+
+  // Apply changes
+  let pulled = 0;
+  let conflictCount = 0;
+  let unchangedCount = diff.unchanged.length;
 
-    const localPath = path.join(outputDir, file.path.replace(/^\//, ''));
-    const localDir = path.dirname(localPath);
+  console.log('');
+
+  // Pull files that changed remotely (and we didn't change locally)
+  for (const p of [...diff.toPull, ...diff.newRemote]) {
+    const content = remoteContent[p];
+    if (!content && content !== '') continue;
+    const localPath = path.join(outputDir, p.replace(/^\//, ''));
+    fs.mkdirSync(path.dirname(localPath), { recursive: true });
+    fs.writeFileSync(localPath, content);
+    const label = diff.newRemote.includes(p) ? 'new on computer' : 'updated on computer';
+    const icon = diff.newRemote.includes(p) ? '+' : '\u2193';
+    console.log(`  ${icon} ${p.replace(/^\//, '')}  ${label}`);
+    pulled++;
+  }
 
-    // Check if unchanged
-    if (fs.existsSync(localPath)) {
-      const existing = fs.readFileSync(localPath, 'utf8');
-      if (existing === file.content) {
-        skipped++;
-        continue;
+  // Handle conflicts
+  for (const p of diff.conflicts) {
+    if (force) {
+      // Force mode: pull remote version, overwrite local
+      const content = remoteContent[p];
+      if (!content && content !== '') continue;
+      const localPath = path.join(outputDir, p.replace(/^\//, ''));
+      fs.mkdirSync(path.dirname(localPath), { recursive: true });
+      fs.writeFileSync(localPath, content);
+      console.log(`  ! ${p.replace(/^\//, '')}  overwritten (--force)`);
+      pulled++;
+    } else {
+      // Save remote version alongside local
+      const content = remoteContent[p];
+      if (content || content === '') {
+        const localPath = path.join(outputDir, p.replace(/^\//, '') + '.remote');
+        fs.mkdirSync(path.dirname(localPath), { recursive: true });
+        fs.writeFileSync(localPath, content);
       }
+      console.log(`  \u26A0 ${p.replace(/^\//, '')}  CONFLICT \u2014 both you and the computer changed this`);
+      console.log(`    \u2192 Remote version saved as ${p.replace(/^\//, '')}.remote`);
+      conflictCount++;
     }
+  }
 
-    fs.mkdirSync(localDir, { recursive: true });
-    fs.writeFileSync(localPath, file.content);
-    written++;
+  // Warn about remote deletions
+  for (const p of diff.deletedRemote) {
+    console.log(`  - ${p.replace(/^\//, '')}  deleted on computer`);
   }
 
+  // Show unchanged
+  if (unchangedCount > 0 && pulled === 0 && conflictCount === 0 && diff.deletedRemote.length === 0) {
+    console.log('  Already up to date.');
+  }
+
+  // Summary
   console.log('');
-  if (written > 0) {
-    console.log(`  ${written} file${written > 1 ? 's' : ''} pulled to ${outputDir}`);
+  const parts = [];
+  if (pulled > 0) parts.push(`${pulled} pulled`);
+  if (diff.newRemote.length > 0 && !parts.some(p => p.includes('pulled'))) parts.push(`${diff.newRemote.length} new`);
+  if (unchangedCount > 0) parts.push(`${unchangedCount} unchanged`);
+  if (conflictCount > 0) parts.push(`${conflictCount} conflict${conflictCount > 1 ? 's' : ''}`);
+  if (diff.deletedRemote.length > 0) parts.push(`${diff.deletedRemote.length} deleted remotely`);
+  if (parts.length > 0) console.log(`  ${parts.join(', ')}.`);
+
+  // Get current commit hash from remote (for manifest)
+  let commitHash = null;
+  try {
+    const headResult = await apiRequestJson(
+      `/businesses/${businessId}/workspaces/${workspaceId}/git/head`,
+      { method: 'GET', token: creds.token }
+    );
+    if (headResult.ok && headResult.data && headResult.data.commit) {
+      commitHash = headResult.data.commit;
+    }
+  } catch {
+    // Git might not be initialized yet — that's fine
   }
-  if (skipped > 0) {
-    console.log(`  ${skipped} unchanged`);
+
+  // Save manifest — when using --only, merge into existing manifest to avoid data loss
+  let manifestFiles = remoteFiles;
+  if (onlyPrefixes && manifest && manifest.files) {
+    manifestFiles = { ...manifest.files, ...remoteFiles };
   }
-  console.log(`\n  Total: ${files.length} files (${result.data.total_size} bytes)`);
+  const newManifest = buildManifest(manifestFiles, commitHash);
+  saveManifest(resolvedSlug || slug, newManifest);
+}
+
+
+function _timeSince(isoString) {
+  if (!isoString) return null;
+  const diff = Date.now() - new Date(isoString).getTime();
+  const mins = Math.floor(diff / 60000);
+  if (mins < 1) return 'just now';
+  if (mins < 60) return `${mins}m ago`;
+  const hours = Math.floor(mins / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  return `${days}d ago`;
 }
 
 

package/commands/push.js

@@ -3,21 +3,29 @@ const path = require('path');
 const { loadCredentials } = require('../utils/auth');
 const { apiRequestJson } = require('../utils/api');
 const { loadBusinesses, saveBusinesses } = require('./business');
+const { loadManifest, saveManifest, computeFileHash, buildManifest, computeLocalHashes, threeWayCompare, SKIP_DIRS } = require('../lib/manifest');
 
 async function pushAtris() {
   const slug = process.argv[3];
 
   if (!slug || slug === '--help') {
-    console.log('Usage: atris push <business-slug> [--from <path>]');
+    console.log('Usage: atris push <business-slug> [--from <path>] [--force]');
     console.log('');
     console.log('Push local files to a Business Computer.');
     console.log('');
+    console.log('Options:');
+    console.log('  --from <path>   Push from a custom directory');
+    console.log('  --force         Push everything, overwrite conflicts');
+    console.log('');
     console.log('Examples:');
     console.log('  atris push pallet                    Push from atris/pallet/ or ./pallet/');
     console.log('  atris push pallet --from ./my-dir/   Push from a custom directory');
+    console.log('  atris push pallet --force             Override conflicts');
     process.exit(0);
   }
 
+  const force = process.argv.includes('--force');
+
   const creds = loadCredentials();
   if (!creds || !creds.token) {
     console.error('Not logged in. Run: atris login');
@@ -50,15 +58,15 @@ async function pushAtris() {
   }
 
   // Resolve business ID
-  let businessId, workspaceId, businessName;
+  let businessId, workspaceId, businessName, resolvedSlug;
   const businesses = loadBusinesses();
 
   if (businesses[slug]) {
     businessId = businesses[slug].business_id;
     workspaceId = businesses[slug].workspace_id;
     businessName = businesses[slug].name || slug;
+    resolvedSlug = businesses[slug].slug || slug;
   } else {
-    // Try to find by slug via API
     const listResult = await apiRequestJson('/businesses/', { method: 'GET', token: creds.token });
     if (!listResult.ok) {
       console.error(`Failed to fetch businesses: ${listResult.errorMessage || listResult.status}`);
@@ -74,8 +82,8 @@ async function pushAtris() {
     businessId = match.id;
     workspaceId = match.workspace_id;
     businessName = match.name;
+    resolvedSlug = match.slug;
 
-    // Auto-save
     businesses[slug] = {
       business_id: businessId,
       workspace_id: workspaceId,
@@ -91,80 +99,165 @@ async function pushAtris() {
     process.exit(1);
   }
 
-  // Walk local directory and collect files
-  const files = [];
-  const SKIP_DIRS = new Set(['node_modules', '__pycache__', '.git', 'venv', '.venv', 'lost+found', '.cache']);
-
-  function walkDir(dir) {
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      if (entry.name.startsWith('.')) continue;
-      const fullPath = path.join(dir, entry.name);
-
-      if (entry.isDirectory()) {
-        if (SKIP_DIRS.has(entry.name)) continue;
-        walkDir(fullPath);
-      } else if (entry.isFile()) {
-        const relPath = '/' + path.relative(sourceDir, fullPath);
-        try {
-          const content = fs.readFileSync(fullPath, 'utf8');
-          files.push({ path: relPath, content });
-        } catch {
-          // Skip binary files
-        }
-      }
-    }
-  }
+  // Load manifest (last sync state)
+  const manifest = loadManifest(resolvedSlug || slug);
 
-  walkDir(sourceDir);
+  // Compute local file hashes
+  const localFiles = computeLocalHashes(sourceDir);
 
-  if (files.length === 0) {
+  if (Object.keys(localFiles).length === 0) {
     console.log(`\nNo files to push from ${sourceDir}`);
     return;
   }
 
+  // Get remote snapshot for three-way compare
   console.log('');
-  console.log(`Pushing ${files.length} files to ${businessName}...`);
-
-  // Sync — one API call pushes everything
-  const result = await apiRequestJson(
-    `/businesses/${businessId}/workspaces/${workspaceId}/sync`,
-    {
-      method: 'POST',
-      token: creds.token,
-      body: { files },
-    }
+  console.log(`Pushing to ${businessName}...`);
+
+  // Get snapshot with content to compute reliable hashes (server hash may differ)
+  const snapshotResult = await apiRequestJson(
+    `/businesses/${businessId}/workspaces/${workspaceId}/snapshot?include_content=true`,
+    { method: 'GET', token: creds.token, timeoutMs: 120000 }
   );
 
-  if (!result.ok) {
-    const msg = result.errorMessage || `HTTP ${result.status}`;
-    if (result.status === 409) {
-      console.error(`\nComputer is sleeping. Wake it first, then push.`);
-    } else if (result.status === 403) {
-      console.error(`\nAccess denied: ${msg}`);
-    } else {
-      console.error(`\nPush failed: ${msg}`);
+  let remoteFiles = {};
+  if (snapshotResult.ok && snapshotResult.data && snapshotResult.data.files) {
+    for (const file of snapshotResult.data.files) {
+      if (file.path && !file.binary && file.content != null) {
+        // Compute hash from content (matches how computeLocalHashes works on raw bytes)
+        const rawBytes = Buffer.from(file.content, 'utf-8');
+        const hash = require('crypto').createHash('sha256').update(rawBytes).digest('hex');
+        remoteFiles[file.path] = { hash, size: rawBytes.length };
+      }
     }
-    process.exit(1);
   }
 
-  const data = result.data;
-  console.log('');
-  if (data.written > 0) {
-    console.log(`  ${data.written} file${data.written > 1 ? 's' : ''} written`);
+  // Three-way compare
+  const diff = threeWayCompare(localFiles, remoteFiles, manifest);
+
+  // Determine what to push
+  const filesToPush = [];
+
+  // Files we changed that remote didn't
+  for (const p of [...diff.toPush, ...diff.newLocal]) {
+    const localPath = path.join(sourceDir, p.replace(/^\//, ''));
+    try {
+      const content = fs.readFileSync(localPath, 'utf8');
+      filesToPush.push({ path: p, content });
+    } catch {
+      // skip
+    }
+  }
+
+  // Force mode: also push conflicts
+  const conflictPaths = [];
+  if (force) {
+    for (const p of diff.conflicts) {
+      const localPath = path.join(sourceDir, p.replace(/^\//, ''));
+      try {
+        const content = fs.readFileSync(localPath, 'utf8');
+        filesToPush.push({ path: p, content });
+      } catch {
+        // skip
+      }
+    }
+  } else {
+    for (const p of diff.conflicts) {
+      conflictPaths.push(p);
+    }
   }
-  if (data.unchanged > 0) {
-    console.log(`  ${data.unchanged} unchanged`);
+
+  console.log('');
+
+  if (filesToPush.length === 0 && conflictPaths.length === 0) {
+    console.log('  Already up to date.');
+    console.log('');
+    return;
   }
-  if (data.errors > 0) {
-    console.log(`  ${data.errors} error${data.errors > 1 ? 's' : ''}`);
-    for (const r of (data.results || [])) {
-      if (r.status === 'error') {
-        console.log(`    ${r.path}: ${r.error}`);
+
+  // Push the files
+  let pushed = 0;
+  if (filesToPush.length > 0) {
+    const result = await apiRequestJson(
+      `/businesses/${businessId}/workspaces/${workspaceId}/sync`,
+      {
+        method: 'POST',
+        token: creds.token,
+        body: { files: filesToPush },
+        headers: { 'X-Atris-Actor-Source': 'cli' },
+      }
+    );
+
+    if (!result.ok) {
+      const msg = result.errorMessage || `HTTP ${result.status}`;
+      if (result.status === 409) {
+        console.error(`  Computer is sleeping. Wake it first, then push.`);
+      } else if (result.status === 403) {
+        console.error(`  Access denied: ${msg}`);
+      } else {
+        console.error(`  Push failed: ${msg}`);
+      }
+      process.exit(1);
+    }
+
+    // Display results
+    for (const p of diff.toPush) {
+      console.log(`  \u2191 ${p.replace(/^\//, '')}  pushing your changes`);
+      pushed++;
+    }
+    for (const p of diff.newLocal) {
+      console.log(`  + ${p.replace(/^\//, '')}  new file`);
+      pushed++;
+    }
+    if (force) {
+      for (const p of diff.conflicts) {
+        console.log(`  ! ${p.replace(/^\//, '')}  overwritten (--force)`);
+        pushed++;
       }
     }
   }
-  console.log(`\n  Synced to ${businessName}.`);
+
+  // Show conflicts
+  for (const p of conflictPaths) {
+    console.log(`  \u26A0 ${p.replace(/^\//, '')}  CONFLICT \u2014 skipped (use --force to override)`);
+  }
+
+  // Show unchanged
+  if (diff.unchanged.length > 0) {
+    // Don't list them all, just count
+  }
+
+  // Summary
+  console.log('');
+  const parts = [];
+  if (pushed > 0) parts.push(`${pushed} pushed`);
+  if (diff.unchanged.length > 0) parts.push(`${diff.unchanged.length} unchanged`);
+  if (conflictPaths.length > 0) parts.push(`${conflictPaths.length} conflict${conflictPaths.length > 1 ? 's' : ''}`);
+  if (parts.length > 0) console.log(`  ${parts.join(', ')}.`);
+
+  // Get commit hash after push
+  let commitHash = null;
+  try {
+    const headResult = await apiRequestJson(
+      `/businesses/${businessId}/workspaces/${workspaceId}/git/head`,
+      { method: 'GET', token: creds.token }
+    );
+    if (headResult.ok && headResult.data && headResult.data.commit) {
+      commitHash = headResult.data.commit;
+    }
+  } catch {
+    // Git might not be initialized yet
+  }
+
+  // Update manifest with new state (merge local + remote)
+  const mergedFiles = { ...remoteFiles };
+  for (const p of Object.keys(localFiles)) {
+    if (filesToPush.some(f => f.path === p)) {
+      mergedFiles[p] = localFiles[p]; // we pushed this, so our hash is now the truth
+    }
+  }
+  const newManifest = buildManifest(mergedFiles, commitHash);
+  saveManifest(resolvedSlug || slug, newManifest);
 }
 
 module.exports = { pushAtris };