atris 3.12.0 → 3.13.0

package/commands/feedback.js

@@ -2,9 +2,15 @@
  * Feedback command for Atris CLI
  *
  * Usage:
- *   atris feedback "message here"  - Submit feedback
- *   atris feedback                 - List your feedback
- *   atris feedback list            - List your feedback
+ *   atris feedback "message here"              Submit feedback
+ *   atris feedback                              List feedback
+ *   atris feedback list                         List feedback
+ *   atris feedback resolve <id> "<resolution>"  Mark resolved (admin)
+ *   atris feedback close <id>                   Close as wontfix (admin)
+ *   atris feedback delete <id>                  Delete feedback (admin)
+ *
+ * IDs may be the first 8 chars of the UUID — the CLI resolves the prefix
+ * against the live list before making the write request.
  */
 
 const fs = require('fs');
@@ -21,40 +27,17 @@ function getAuth() {
   return { token: creds.token, email: creds.email || 'unknown' };
 }
 
-function getBusinessId() {
-  // 1. Check .atris/business.json in current directory
-  const bizFile = path.join(process.cwd(), '.atris', 'business.json');
-  if (fs.existsSync(bizFile)) {
-    try {
-      const biz = JSON.parse(fs.readFileSync(bizFile, 'utf8'));
-      if (biz.business_id) return biz.business_id;
-    } catch {}
-  }
-
-  // 2. Check ~/.atris/businesses.json (first connected business)
-  const home = require('os').homedir();
-  const globalBizFile = path.join(home, '.atris', 'businesses.json');
-  if (fs.existsSync(globalBizFile)) {
-    try {
-      const businesses = JSON.parse(fs.readFileSync(globalBizFile, 'utf8'));
-      const slugs = Object.keys(businesses);
-      if (slugs.length > 0 && businesses[slugs[0]].business_id) {
-        return businesses[slugs[0]].business_id;
-      }
-    } catch {}
-  }
-
-  return null;
-}
-
-async function submitFeedback(message) {
+async function submitFeedback(message, opts = {}) {
   if (!message) {
-    console.error('Usage: atris feedback "your message here"');
+    console.error('Usage: atris feedback "your message here" [--business <slug|id>]');
     process.exit(1);
   }
 
   const { token } = getAuth();
-  const businessId = getBusinessId();
+  // Only attach business_id when the user explicitly asked for it via --business.
+  // Auto-scoping to "first business in businesses.json" silently hid feedback
+  // from every other workspace the user belongs to.
+  const businessId = opts.businessId || null;
 
   const body = {
     message,
@@ -81,70 +64,239 @@ async function submitFeedback(message) {
   }
 }
 
+async function fetchFeedbackItems({ token, businessId, limit = 100, status = null } = {}) {
+  let url = `/feedback?limit=${limit}`;
+  if (businessId) url += `&business_id=${businessId}`;
+  if (status) url += `&status=${encodeURIComponent(status)}`;
+
+  const result = await apiRequestJson(url, { method: 'GET', token });
+  if (!result.ok) {
+    console.error(`Error: ${result.error || 'Failed to fetch feedback'}`);
+    process.exit(1);
+  }
+  return result.data?.feedback || [];
+}
+
 async function listFeedback() {
   const { token } = getAuth();
-  const businessId = getBusinessId();
+  // Do NOT auto-scope by business: admins expect to see the full queue.
+  // The API already scopes non-admins to their own businesses server-side.
+  const items = await fetchFeedbackItems({ token, limit: 20 });
 
-  let url = '/feedback?limit=20';
-  if (businessId) {
-    url += `&business_id=${businessId}`;
+  if (items.length === 0) {
+    console.log('No feedback found.');
+    return;
+  }
+
+  console.log(`Feedback Queue (${items.length} item${items.length !== 1 ? 's' : ''})\n`);
+
+  items.forEach((item, idx) => {
+    const status = (item.status || 'open').toUpperCase();
+    const shortId = (item.id || '').substring(0, 8);
+    const msg = item.message || '';
+    const preview = msg.length > 120 ? msg.substring(0, 120) + '...' : msg;
+    const date = item.created_at
+      ? new Date(item.created_at).toLocaleDateString('en-US', { month: 'short', day: 'numeric' })
+      : '';
+    const fromEmail = item.context?.user_email || item.user_id || '';
+
+    console.log(`${idx + 1}. [${status}] id:${shortId}${date ? '  ' + date : ''}`);
+    console.log(`   "${preview}"`);
+    if (fromEmail) console.log(`   from: ${fromEmail}`);
+    if (item.resolution) console.log(`   resolution: ${item.resolution}`);
+    console.log('');
+  });
+}
+
+/**
+ * Resolve a short ID prefix (or full UUID) to the full UUID by scanning
+ * the list endpoint. Returns null if no unique match found.
+ */
+async function resolveIdPrefix(prefix, { token, businessId }) {
+  if (!prefix) return { error: 'ID required' };
+  // If it looks like a full UUID, trust it
+  if (prefix.length >= 32) return { id: prefix };
+
+  const items = await fetchFeedbackItems({ token, businessId, limit: 200 });
+  const matches = items.filter(it => (it.id || '').startsWith(prefix));
+
+  if (matches.length === 0) return { error: `No feedback matches id prefix "${prefix}"` };
+  if (matches.length > 1) {
+    return {
+      error: `Ambiguous id "${prefix}" — matches ${matches.length} items. Use a longer prefix.`,
+    };
   }
+  return { id: matches[0].id, item: matches[0] };
+}
+
+async function resolveFeedback(idPrefix, resolution) {
+  if (!idPrefix || !resolution) {
+    console.error('Usage: atris feedback resolve <id> "<resolution>"');
+    process.exit(1);
+  }
+  const { token } = getAuth();
 
-  const result = await apiRequestJson(url, {
-    method: 'GET',
+  const lookup = await resolveIdPrefix(idPrefix, { token });
+  if (lookup.error) {
+    console.error(`Error: ${lookup.error}`);
+    process.exit(1);
+  }
+
+  const result = await apiRequestJson(`/feedback/${lookup.id}`, {
+    method: 'PATCH',
     token,
+    body: { status: 'resolved', resolution },
   });
 
   if (!result.ok) {
-    console.error(`Error: ${result.error || 'Failed to fetch feedback'}`);
+    console.error(`Error: ${result.error || 'Failed to resolve feedback'}`);
     process.exit(1);
   }
+  console.log(`Resolved ${lookup.id.substring(0, 8)}: ${resolution}`);
+}
 
-  const items = result.data?.feedback || [];
+async function closeFeedback(idPrefix) {
+  if (!idPrefix) {
+    console.error('Usage: atris feedback close <id>');
+    process.exit(1);
+  }
+  const { token } = getAuth();
 
-  if (items.length === 0) {
-    console.log('No feedback found.');
-    return;
+  const lookup = await resolveIdPrefix(idPrefix, { token });
+  if (lookup.error) {
+    console.error(`Error: ${lookup.error}`);
+    process.exit(1);
+  }
+
+  const result = await apiRequestJson(`/feedback/${lookup.id}`, {
+    method: 'PATCH',
+    token,
+    body: { status: 'closed' },
+  });
+
+  if (!result.ok) {
+    console.error(`Error: ${result.error || 'Failed to close feedback'}`);
+    process.exit(1);
   }
+  console.log(`Closed ${lookup.id.substring(0, 8)}`);
+}
 
-  console.log(`${items.length} feedback item${items.length !== 1 ? 's' : ''}:\n`);
+async function deleteFeedback(idPrefix) {
+  if (!idPrefix) {
+    console.error('Usage: atris feedback delete <id>');
+    process.exit(1);
+  }
+  const { token } = getAuth();
 
-  for (const item of items) {
-    const date = item.created_at
-      ? new Date(item.created_at).toLocaleDateString('en-US', { month: 'short', day: 'numeric', year: 'numeric' })
-      : '';
-    const status = item.status || 'open';
-    const msg = item.message || '';
-    const preview = msg.length > 80 ? msg.substring(0, 80) + '...' : msg;
-
-    console.log(`  [${status}] ${preview}`);
-    if (date || item.id) {
-      const parts = [];
-      if (date) parts.push(date);
-      if (item.id) parts.push(item.id.substring(0, 8));
-      console.log(`         ${parts.join('  ')}`);
+  const lookup = await resolveIdPrefix(idPrefix, { token });
+  if (lookup.error) {
+    console.error(`Error: ${lookup.error}`);
+    process.exit(1);
+  }
+
+  const result = await apiRequestJson(`/feedback/${lookup.id}`, {
+    method: 'DELETE',
+    token,
+  });
+
+  if (!result.ok) {
+    console.error(`Error: ${result.error || 'Failed to delete feedback'}`);
+    process.exit(1);
+  }
+  console.log(`Deleted ${lookup.id.substring(0, 8)}`);
+}
+
+function printHelp() {
+  console.log('');
+  console.log('Usage:');
+  console.log('  atris feedback "message"               Submit feedback (global)');
+  console.log('  atris feedback "msg" --business <slug> Submit feedback tagged to a business');
+  console.log('  atris feedback                         List feedback');
+  console.log('  atris feedback list                    List feedback');
+  console.log('  atris feedback resolve <id> "<note>"   Mark resolved (admin)');
+  console.log('  atris feedback close <id>              Close as wontfix (admin)');
+  console.log('  atris feedback delete <id>             Delete feedback (admin)');
+  console.log('');
+  console.log('IDs may be the first 8 chars of the UUID.');
+  console.log('Business slugs come from ~/.atris/businesses.json (e.g. pallet, atris-labs-1).');
+  console.log('');
+}
+
+function resolveBusinessArg(value) {
+  if (!value) return null;
+  // Full UUID — trust it
+  if (/^[0-9a-f-]{32,}$/i.test(value)) return value;
+  // Otherwise treat as slug and look up in ~/.atris/businesses.json
+  const home = require('os').homedir();
+  const file = path.join(home, '.atris', 'businesses.json');
+  if (!fs.existsSync(file)) return null;
+  try {
+    const map = JSON.parse(fs.readFileSync(file, 'utf8'));
+    const hit = map[value] || Object.values(map).find(b => b.slug === value);
+    return hit ? hit.business_id : null;
+  } catch {
+    return null;
+  }
+}
+
+function extractFlag(args, ...names) {
+  // Returns [value, remainingArgs]. Supports "--flag val" and "--flag=val".
+  const remaining = [];
+  let value = null;
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    const eq = a.indexOf('=');
+    const key = eq >= 0 ? a.slice(0, eq) : a;
+    if (names.includes(key)) {
+      value = eq >= 0 ? a.slice(eq + 1) : args[++i];
+    } else {
+      remaining.push(a);
     }
-    console.log('');
   }
+  return [value, remaining];
 }
 
 async function feedbackCommand() {
-  const subcommand = process.argv[3];
+  const rawArgs = process.argv.slice(3);
+  const [businessArg, args] = extractFlag(rawArgs, '--business', '-b');
+  const businessId = resolveBusinessArg(businessArg);
+  if (businessArg && !businessId) {
+    console.error(`Error: unknown business "${businessArg}". Check ~/.atris/businesses.json`);
+    process.exit(1);
+  }
+
+  const subcommand = args[0];
 
   if (!subcommand || subcommand === 'list') {
     await listFeedback();
-  } else if (subcommand === '--help' || subcommand === '-h') {
-    console.log('');
-    console.log('Usage:');
-    console.log('  atris feedback "message"   Submit feedback');
-    console.log('  atris feedback             List your feedback');
-    console.log('  atris feedback list        List your feedback');
-    console.log('');
-  } else {
-    // Everything else is a feedback message
-    const message = process.argv.slice(3).join(' ');
-    await submitFeedback(message);
+    return;
   }
+
+  if (subcommand === '--help' || subcommand === '-h' || subcommand === 'help') {
+    printHelp();
+    return;
+  }
+
+  if (subcommand === 'resolve') {
+    const id = args[1];
+    const resolution = args.slice(2).join(' ');
+    await resolveFeedback(id, resolution);
+    return;
+  }
+
+  if (subcommand === 'close') {
+    await closeFeedback(args[1]);
+    return;
+  }
+
+  if (subcommand === 'delete') {
+    await deleteFeedback(args[1]);
+    return;
+  }
+
+  // Everything else is a feedback message
+  const message = args.join(' ');
+  await submitFeedback(message, { businessId });
 }
 
 module.exports = { feedbackCommand };

package/commands/proof.js

@@ -0,0 +1,115 @@
+const fs = require('fs');
+const path = require('path');
+
+function readBusinessBinding(cwd = process.cwd()) {
+  const bindingPath = path.join(cwd, '.atris', 'business.json');
+  if (!fs.existsSync(bindingPath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(bindingPath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function slugify(value) {
+  return String(value || 'business-workflow')
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '') || 'business-workflow';
+}
+
+function ensureDir(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+}
+
+function writeJson(filePath, value) {
+  ensureDir(path.dirname(filePath));
+  fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+function doctor(cwd = process.cwd()) {
+  const binding = readBusinessBinding(cwd);
+  console.log('Receipt check');
+  console.log(`business binding: ${binding ? `${binding.name || binding.slug || binding.business_id} ready` : 'missing'}`);
+  console.log(`receipt folder: ${fs.existsSync(path.join(cwd, '.atris', 'receipts')) ? 'ready' : 'missing'}`);
+  console.log('');
+  console.log('Next: atris receipt init business-workflow');
+}
+
+function init(taskSlug = 'business-workflow', cwd = process.cwd()) {
+  const binding = readBusinessBinding(cwd);
+  if (!binding) {
+    console.error('No business binding found. Run: atris business init <name> --here');
+    process.exitCode = 1;
+    return;
+  }
+
+  const slug = slugify(taskSlug);
+  const root = path.join(cwd, '.atris');
+  const taskPath = path.join(root, 'tasks', `${slug}.json`);
+  const receiptsDir = path.join(root, 'receipts');
+
+  ensureDir(receiptsDir);
+  fs.writeFileSync(path.join(receiptsDir, '.gitkeep'), '');
+  writeJson(taskPath, {
+    schema: 'atris.receipt_task.v1',
+    slug,
+    goal: 'Run one business-computer task and save what happened.',
+    workspace: {
+      business_id: binding.business_id || binding.id || null,
+      workspace_id: binding.workspace_id || null,
+      name: binding.name || null,
+      slug: binding.slug || null,
+    },
+    runtime: {
+      proof_command: 'atris computer proof',
+      replay_command: 'atris experiments replay endstate',
+    },
+    verify: [
+      'atris computer proof',
+      'atris experiments replay endstate',
+    ],
+  });
+
+  console.log(`Receipt task ready: ${slug}`);
+  console.log(`Task: ${path.relative(cwd, taskPath)}`);
+  console.log(`Receipts: ${path.relative(cwd, receiptsDir)}`);
+}
+
+function run(args = []) {
+  const dryRun = args.includes('--dry-run');
+  console.log('Receipt run');
+  console.log('1. atris computer proof');
+  console.log('2. atris experiments replay endstate');
+  if (dryRun) {
+    console.log('Dry run only; no receipts written.');
+    return;
+  }
+  console.log('Run those commands, then save the receipt under .atris/receipts/.');
+}
+
+function proofCommand(subcommand = 'doctor', ...args) {
+  switch (subcommand || 'doctor') {
+    case 'doctor':
+      return doctor();
+    case 'init':
+      return init(args[0] || 'business-workflow');
+    case 'proof':
+      return run(args);
+    case 'help':
+    case '--help':
+    case '-h':
+      console.log('Usage: atris receipt [doctor|init <slug>|run --dry-run]');
+      return;
+    case 'run':
+      return run(args);
+    default:
+      console.error(`Unknown receipt command: ${subcommand}`);
+      console.log('Usage: atris receipt [doctor|init <slug>|run --dry-run]');
+      process.exitCode = 1;
+  }
+}
+
+module.exports = {
+  proofCommand,
+};

package/commands/pull.js

@@ -703,8 +703,10 @@ async function pullBusiness(slug) {
     name: businessName,
   }, null, 2));
 
-  // Wire skills → .claude/skills/ so they work as slash commands
-  const skillsDir = path.join(outputDir, 'skills');
+  // Wire skills → .claude/skills/ so they work as slash commands.
+  // Source of truth is atris/skills/ (vendor-neutral, syncs to cloud).
+  // .claude/skills/ is a locally-generated adapter Claude Code reads from.
+  const skillsDir = path.join(outputDir, 'atris', 'skills');
   const claudeSkillsDir = path.join(outputDir, '.claude', 'skills');
 
   if (fs.existsSync(skillsDir)) {

package/commands/push.js

@@ -367,6 +367,12 @@ async function pushAtris() {
 
     if (!result.ok) {
       if (result.status === 403) {
+        const detail = result.errorMessage || result.error || (result.data && result.data.detail) || '';
+        if (detail && /plan required|business, max, or enterprise/i.test(detail)) {
+          console.error(`\n  Access denied: ${detail}`);
+          await emit('access_denied', { error_detail: detail });
+          process.exit(1);
+        }
         // Permission denied — retry with only team/ and journal/ files
         const allowed = filesToPush.filter(f => f.path.startsWith('/team/') || f.path.startsWith('/journal/'));
         skipped = filesToPush.filter(f => !f.path.startsWith('/team/') && !f.path.startsWith('/journal/'));