atris 3.15.23 → 3.15.31

package/commands/computer.js

@@ -3,6 +3,7 @@
  *
  *   atris computer                  — Open SMART mode (cloud in business workspace, local elsewhere)
  *   atris computer --cloud          — Open CLOUD workspace mode
+ *   atris computer create <name>    — Create and wake a business computer
  *   atris computer wake             — Start the computer
  *   atris computer sleep            — Stop (files persist)
  *   atris computer card             — Show the local computer card
@@ -19,7 +20,7 @@ const path = require('path');
 const readline = require('readline');
 const { spawnSync } = require('child_process');
 const { loadCredentials, decodeJwtClaims } = require('../utils/auth');
-const { apiRequestJson, getApiBaseUrl } = require('../utils/api');
+const { apiRequestJson, getApiBaseUrl, getAppBaseUrl } = require('../utils/api');
 const { loadBusinesses, saveBusinesses } = require('./business');
 const { consoleCommand, gatherAtrisContext, buildSystemPrompt } = require('./console');
 const { streamSession } = require('./serve');
@@ -544,6 +545,36 @@ function parseComputerOptions(argv) {
   };
 }
 
+function parseComputerCreateArgs(argv = []) {
+  const nameParts = [];
+  let businessSlug = null;
+  let help = false;
+
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === '--help' || arg === '-h' || arg === 'help') {
+      help = true;
+      continue;
+    }
+    if ((arg === '--business' || arg === '-b') && argv[i + 1]) {
+      businessSlug = argv[i + 1];
+      i++;
+      continue;
+    }
+    if (arg.startsWith('--business=')) {
+      businessSlug = arg.split('=', 2)[1] || null;
+      continue;
+    }
+    nameParts.push(arg);
+  }
+
+  return {
+    name: nameParts.join(' ').trim(),
+    businessSlug: businessSlug ? String(businessSlug).trim() : null,
+    help,
+  };
+}
+
 function formatCloudSelection(options = {}) {
   const worker = activeWorker(options.worker);
   const parts = [`worker=${worker}`];
@@ -953,6 +984,55 @@ async function resolveBusinessContextBySlug(token, slug) {
   return null;
 }
 
+async function resolveBusinessOwnerForCreate(token, businessSlug = null) {
+  const wantedSlug = businessSlug ? String(businessSlug).trim() : null;
+  if (wantedSlug) {
+    const fromApi = await resolveBusinessContextBySlug(token, wantedSlug);
+    if (fromApi) return fromApi;
+
+    const cached = loadBusinesses()[wantedSlug];
+    if (cached?.business_id) {
+      return {
+        slug: cached.slug || wantedSlug,
+        businessId: cached.business_id,
+        workspaceId: cached.workspace_id || null,
+        businessName: cached.name || cached.slug || wantedSlug,
+      };
+    }
+    return null;
+  }
+
+  const binding = readBusinessBinding();
+  if (binding?.business_id) {
+    return {
+      slug: binding.slug || binding.canonical_slug || null,
+      businessId: binding.business_id,
+      workspaceId: binding.workspace_id || null,
+      businessName: binding.name || binding.slug || 'business',
+    };
+  }
+
+  return resolveBusinessContext(token);
+}
+
+function rememberCreatedComputer(ctx, workspace, endpoint = null) {
+  const slug = ctx.slug || (ctx.businessName || '').toLowerCase().replace(/\s+/g, '-');
+  if (!slug) return;
+  const businesses = loadBusinesses();
+  businesses[slug] = {
+    ...(businesses[slug] || {}),
+    business_id: ctx.businessId,
+    workspace_id: workspace.id,
+    name: ctx.businessName,
+    slug,
+    computer_name: workspace.name,
+    endpoint: endpoint || undefined,
+    added_at: businesses[slug]?.added_at || new Date().toISOString(),
+    updated_at: new Date().toISOString(),
+  };
+  saveBusinesses(businesses);
+}
+
 function shellQuote(value) {
   return `'${String(value).replace(/'/g, `'\\''`)}'`;
 }
@@ -1224,6 +1304,90 @@ async function computerWake(token, ctx = null) {
   console.log(`  Endpoint: ${result.data.endpoint}`);
 }
 
+async function computerCreate(token, args = []) {
+  const options = parseComputerCreateArgs(args);
+  if (options.help || !options.name) {
+    console.log('Usage: atris computer create <name> --business <slug>');
+    console.log('');
+    console.log('Create a business computer, activate it, and wake it in one command.');
+    console.log('');
+    console.log('Examples:');
+    console.log('  atris computer create "My Business Computer" --business atris-labs');
+    console.log('  atris computer create "Recruiting Computer"');
+    if (!options.name && !options.help) process.exitCode = 1;
+    return;
+  }
+
+  const ctx = await resolveBusinessOwnerForCreate(token, options.businessSlug);
+  if (!ctx?.businessId) {
+    console.error('No business found.');
+    console.error('Run inside a bound business workspace or pass: --business <slug>');
+    process.exitCode = 1;
+    return;
+  }
+
+  console.log(`Creating computer "${options.name}" for ${ctx.businessName}...`);
+  const created = await apiRequestJson(`/business/${ctx.businessId}/workspaces`, {
+    method: 'POST',
+    token,
+    body: { name: options.name, type: 'general' },
+  });
+  if (!created.ok) {
+    console.error(`Failed to create workspace: ${created.errorMessage || created.error || created.status}`);
+    process.exitCode = 1;
+    return;
+  }
+
+  const workspace = created.data || {};
+  const workspaceId = workspace.id || workspace.workspace_id;
+  if (!workspaceId) {
+    console.error('Failed to create workspace: response did not include workspace id');
+    process.exitCode = 1;
+    return;
+  }
+
+  const activate = await apiRequestJson(`/business/${ctx.businessId}/workspaces/${workspaceId}/activate`, {
+    method: 'POST',
+    token,
+    body: {},
+  });
+  if (!activate.ok && activate.status !== 409) {
+    console.error(`Failed to activate computer: ${activate.errorMessage || activate.error || activate.status}`);
+    process.exitCode = 1;
+    return;
+  }
+
+  const wake = await apiRequestJson(`/business/${ctx.businessId}/ai-computer/wake`, {
+    method: 'POST',
+    token,
+    body: {},
+  });
+  if (!wake.ok && !activate.ok) {
+    console.error(`Failed to wake computer: ${wake.errorMessage || wake.error || wake.status}`);
+    process.exitCode = 1;
+    return;
+  }
+
+  const endpoint = activate.data?.endpoint || wake.data?.endpoint || null;
+  const status = endpoint
+    ? 'running'
+    : (wake.data?.status || (activate.ok ? 'activated' : 'warming_up'));
+  rememberCreatedComputer(ctx, { ...workspace, id: workspaceId, name: workspace.name || options.name }, endpoint);
+
+  const appBase = getAppBaseUrl();
+  console.log('');
+  console.log(`Computer created: ${workspaceId}`);
+  console.log(`  Name:      ${workspace.name || options.name}`);
+  console.log(`  Business:  ${ctx.businessName}`);
+  console.log(`  Status:    ${status}`);
+  if (endpoint) console.log(`  Endpoint:  ${endpoint}`);
+  console.log(`  Dashboard: ${appBase}/dashboard/gm/${ctx.businessId}`);
+  console.log('');
+  console.log('Next:');
+  console.log(`  atris pull ${ctx.slug || ctx.businessId}`);
+  console.log('  atris computer');
+}
+
 async function computerSleep(token, ctx = null) {
   if (ctx) {
     console.log(`Sleeping computer for ${ctx.businessName}...`);
@@ -2562,6 +2726,14 @@ async function runComputer() {
     return;
   }
 
+  if (sub === 'create') {
+    const createOptions = parseComputerCreateArgs(args.slice(1));
+    if (createOptions.help || !createOptions.name) {
+      await computerCreate(null, args.slice(1));
+      return;
+    }
+  }
+
   if (sub === '--help') {
     console.log('Usage: atris computer [mode|command]');
     console.log('');
@@ -2593,6 +2765,7 @@ async function runComputer() {
     console.log('  claude|codex    Legacy local console backends');
     console.log('');
     console.log('Cloud commands:');
+    console.log('  create <name>    Create and wake a business computer');
     console.log('  chat            Interactive cloud workspace chat');
     console.log('                  Ctrl-C during a cloud run interrupts it');
     console.log('                  /start shows the beginner flow');
@@ -2614,6 +2787,7 @@ async function runComputer() {
     console.log('Examples:');
     console.log('  atris computer');
     console.log('  atris computer card --write');
+    console.log('  atris computer create "My Business Computer" --business atris-labs');
     console.log('  atris business init "My Lab"     # shared owner + first/default computer');
     console.log('  atris computer proof');
     console.log('  atris computer local');
@@ -2695,6 +2869,7 @@ async function runComputer() {
   switch (sub) {
     case 'chat': return computerChat(token, ctx, cloudOptions);
     case 'card': return computerCard(args.slice(1));
+    case 'create': return computerCreate(token, args.slice(1));
     case 'proof': return computerProof(token, ctx, cloudOptions);
     case 'status': return computerStatus(token, ctx);
     case 'wake': return computerWake(token, ctx);

package/commands/gm.js

@@ -4,6 +4,9 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 
+const AGENTXP_LEADERBOARD_URL = 'https://api.atris.ai/api/agentxp/leaderboard';
+const AGENTXP_GLOBAL_SYNC_RULE = 'Use the owner-provided sync token first; fallback is atris login before sync.';
+
 const ROLE_PLAYERS_TO_IGNORE = new Set([
   'game-manager',
   'navigator',
@@ -26,7 +29,7 @@ function showHelp() {
   console.log('');
   console.log('Options:');
   console.log('  --manager <id>    Manager id. Defaults to game-manager when present.');
-  console.log('  --as <id>         Alias for --manager.');
+  console.log('  --as <id>         Alias for --player.');
   console.log('  --player <id>     Preferred player when seeding a first local mission.');
   console.log('  --workspace <p>   Read missions from another Atris workspace.');
   console.log('  --no-seed         Do not create a starter player mission.');
@@ -102,7 +105,7 @@ function teamMembers(workspaceRoot) {
 }
 
 function inferManager(workspaceRoot, args = []) {
-  const explicit = flag(args, '--manager') || flag(args, '--as') || positional(args)[0];
+  const explicit = flag(args, '--manager') || positional(args)[0];
   if (explicit) return { manager: slugify(explicit), source: 'flag' };
 
   for (const value of [process.env.ATRIS_GM, process.env.ATRIS_MANAGER, process.env.ATRIS_AGENT_ID]) {
@@ -160,7 +163,7 @@ function starterMissionPrompt(player) {
 }
 
 function pickSeedPlayer(workspaceRoot, tasks, args = []) {
-  const explicit = flag(args, '--player') || flag(args, '--user');
+  const explicit = flag(args, '--player') || flag(args, '--user') || flag(args, '--as');
   if (explicit) return slugify(explicit);
 
   const fromTasks = playersFromTasks(tasks);
@@ -261,19 +264,30 @@ function compactTask(task) {
   };
 }
 
-function nextCommands({ seeded, reviewQueue, missions, players }) {
+function globalSyncCommands(player) {
+  return [
+    `atris xp sync --local --as ${player} --token <owner-provided-token>`,
+    'atris login',
+    `atris xp sync --local --as ${player}`,
+  ];
+}
+
+function nextCommands({ seeded, reviewQueue, missions, players, manager }) {
   if (reviewQueue.length) {
-    const ref = reviewQueue[0].ref;
+    const task = reviewQueue[0];
+    const ref = task.ref;
+    const player = task.assigned_to || task.claimed_by || players[0]?.player || 'player';
     return [
       `atris task show ${ref}`,
-      `atris task accept ${ref} --proof "<human review>"`,
-      `atris task revise ${ref} --note "<what must change>"`,
+      `atris task accept ${ref} --as ${player} --proof "<human review>"`,
+      `atris task revise ${ref} --as ${player} --note "<what must change>"`,
+      ...globalSyncCommands(player),
     ];
   }
   if (missions.length) {
     const mission = missions[0];
     const player = mission.assigned_to || mission.claimed_by || players[0]?.player || 'player';
-    if (mission.status === 'open') return [`atris task claim ${mission.ref} --as ${player}`];
+    if (mission.status === 'open') return [`atris task claim ${mission.ref} --as ${manager || 'game-manager'}`];
     return [`atris play --as ${player}`];
   }
   if (seeded) return [`atris play --as ${seeded.assigned_to || 'player'}`];
@@ -297,7 +311,7 @@ function gmState(args = []) {
   const reviewQueue = missions.filter(task => task.status === 'review');
   const players = groupPlayers(tasks, workspaceRoot);
   const seeded = compactTask(starter.seeded);
-  const commands = nextCommands({ seeded, reviewQueue, missions, players });
+  const commands = nextCommands({ seeded, reviewQueue, missions, players, manager: detected.manager });
 
   return {
     schema: 'atris.agentxp_gm_mode.v1',
@@ -318,6 +332,8 @@ function gmState(args = []) {
     review_queue: reviewQueue,
     next_commands: commands,
     xp_rule: 'GM can route missions and review proof, but AgentXP still lands only after human accept.',
+    global_sync_rule: AGENTXP_GLOBAL_SYNC_RULE,
+    leaderboard_url: AGENTXP_LEADERBOARD_URL,
   };
 }
 
@@ -351,6 +367,8 @@ function render(state) {
 
   console.log('');
   console.log('XP rule: no proof, no AgentXP; accept/revise stays human-gated.');
+  console.log('Global sync: use owner token first; fallback to atris login before hosted leaderboard sync.');
+  console.log(`Leaderboard: ${state.leaderboard_url}`);
   console.log('');
   console.log('Next commands:');
   for (const command of state.next_commands) console.log(`- ${command}`);

package/commands/play.js

@@ -6,6 +6,9 @@ const fs = require('fs');
 const { spawnSync } = require('child_process');
 const { getSessionProfile, loadCredentials } = require('../utils/auth');
 
+const AGENTXP_LEADERBOARD_URL = 'https://api.atris.ai/api/agentxp/leaderboard';
+const AGENTXP_GLOBAL_SYNC_RULE = 'Use the owner-provided sync token first; fallback is atris login before sync.';
+
 function showHelp() {
   console.log('');
   console.log('Usage: atris play [--as <player>] [--workspace <path>] [--json]');
@@ -252,10 +255,18 @@ function starterMissionPrompt(player) {
   ].join(' ');
 }
 
+function globalSyncCommands(player) {
+  return [
+    `atris xp sync --local --as ${player} --token <owner-provided-token>`,
+    'atris login',
+    `atris xp sync --local --as ${player}`,
+  ];
+}
+
 function ensureStarterMission(taskDb, db, workspaceRoot, player, tasks, args = []) {
   if (hasFlag(args, '--no-seed')) return { tasks, seeded: null };
   if (selectMission(tasks, player)) return { tasks, seeded: null };
-  if (!fs.existsSync(path.join(workspaceRoot, 'atris'))) return { tasks, seeded: null };
+  fs.mkdirSync(path.join(workspaceRoot, 'atris'), { recursive: true });
 
   const result = taskDb.addTask(db, {
     title: starterMissionTitle(),
@@ -282,7 +293,21 @@ function ensureStarterMission(taskDb, db, workspaceRoot, player, tasks, args = [
   return { tasks: refreshed, seeded };
 }
 
+function playWorkspaceRoot(taskDb, workspaceArg) {
+  let requested = path.resolve(workspaceArg || process.cwd());
+  try { requested = fs.realpathSync(requested); } catch {}
+  if (
+    fs.existsSync(path.join(requested, '.git'))
+    || fs.existsSync(path.join(requested, 'atris'))
+    || fs.existsSync(path.join(requested, '.atris'))
+  ) {
+    return taskDb.workspaceRoot(requested);
+  }
+  return requested;
+}
+
 function nextCommands(task, player) {
+  const helper = 'game-manager';
   if (!task) {
     return [
       `atris task delegate "AgentXP first rep: one proof-backed mission" --to ${player} --tag agent-xp`,
@@ -293,40 +318,45 @@ function nextCommands(task, player) {
   const ref = taskRef(task);
   if (task.status === 'open') {
     return [
-      `atris task claim ${ref} --as ${player}`,
-      `atris task ready ${ref} --proof "<artifact path + verifier result>"`,
-      `atris task accept ${ref} --proof "<human review>"`,
+      `atris task claim ${ref} --as ${helper}`,
+      `atris task ready ${ref} --as ${helper} --proof "<artifact path + verifier result>"`,
+      `atris task accept ${ref} --as ${player} --proof "<human review>"`,
       'atris xp card --local',
+      ...globalSyncCommands(player),
     ];
   }
 
   if (task.status === 'claimed') {
+    const actor = task.claimed_by || helper;
     return [
-      `atris task ready ${ref} --proof "<artifact path + verifier result>"`,
-      `atris task accept ${ref} --proof "<human review>"`,
+      `atris task ready ${ref} --as ${actor} --proof "<artifact path + verifier result>"`,
+      `atris task accept ${ref} --as ${player} --proof "<human review>"`,
       'atris xp card --local',
+      ...globalSyncCommands(player),
     ];
   }
 
   if (task.status === 'review') {
     return [
       `atris task show ${ref}`,
-      `atris task accept ${ref} --proof "<human review>"`,
-      `atris task revise ${ref} --note "<what must change>"`,
+      `atris task accept ${ref} --as ${player} --proof "<human review>"`,
+      `atris task revise ${ref} --as ${player} --note "<what must change>"`,
       'atris xp card --local',
+      ...globalSyncCommands(player),
     ];
   }
 
   return [
     `atris task show ${ref}`,
     'atris xp card --local',
+    ...globalSyncCommands(player),
   ];
 }
 
 function modeState(args = []) {
   const taskDb = require('../lib/task-db');
   const workspaceArg = flag(args, '--workspace') || flag(args, '--root') || process.cwd();
-  const workspaceRoot = taskDb.workspaceRoot(path.resolve(workspaceArg));
+  const workspaceRoot = playWorkspaceRoot(taskDb, workspaceArg);
   const db = taskDb.open();
   const rows = taskDb.listTasks(db, {
     workspaceRoot,
@@ -367,6 +397,8 @@ function modeState(args = []) {
       prompt: latestMessage(events),
     } : null,
     xp_rule: 'AgentXP lands only after proof is ready and a human accepts the task.',
+    global_sync_rule: AGENTXP_GLOBAL_SYNC_RULE,
+    leaderboard_url: AGENTXP_LEADERBOARD_URL,
     next_commands: commandList,
   };
 }
@@ -399,6 +431,8 @@ function render(state) {
   console.log('');
   console.log('Win condition: real artifact + verifier + human accept.');
   console.log('XP rule: no proof, no AgentXP; accept/revise stays human-gated.');
+  console.log('Global sync: use owner token first; fallback to atris login before hosted leaderboard sync.');
+  console.log(`Leaderboard: ${state.leaderboard_url}`);
   console.log('');
   console.log('Next commands:');
   for (const command of state.next_commands) console.log(`- ${command}`);

package/commands/sync.js

@@ -48,6 +48,10 @@ function _substituteParams(content, params) {
     .replace(/\{\{workspace_template\}\}/g, params.workspace_template || 'business');
 }
 
+function _templateTargetRelPath(relPath) {
+  return relPath === 'persona.md' ? 'PERSONA.md' : relPath;
+}
+
 /**
  * Sync the canonical skill set from atris-cli/atris/skills/* into a
  * workspace's atris/skills/* (plus ensure .claude/skills/ symlinks).
@@ -212,14 +216,15 @@ function syncWorkspaceTemplate(targetRoot, bizMeta, options = {}) {
   const addedList = [], updatedList = [], preservedList = [];
 
   for (const relPath of templateFiles) {
+    const targetRelPath = _templateTargetRelPath(relPath);
     const templatePath = path.join(template.dir, relPath);
-    const targetPath = path.join(targetAtrisDir, relPath);
+    const targetPath = path.join(targetAtrisDir, targetRelPath);
     let templateContent;
     try { templateContent = fs.readFileSync(templatePath, 'utf-8'); } catch { continue; }
     const finalContent = _substituteParams(templateContent, params);
 
     if (!fs.existsSync(targetPath)) {
-      addedList.push(relPath); added++;
+      addedList.push(targetRelPath); added++;
       if (!dryRun) {
         fs.mkdirSync(path.dirname(targetPath), { recursive: true });
         fs.writeFileSync(targetPath, finalContent);
@@ -229,10 +234,10 @@ function syncWorkspaceTemplate(targetRoot, bizMeta, options = {}) {
       if (existing === finalContent) {
         skipped++;
       } else if (force) {
-        updatedList.push(relPath); updated++;
+        updatedList.push(targetRelPath); updated++;
         if (!dryRun) fs.writeFileSync(targetPath, finalContent);
       } else {
-        preservedList.push(relPath); preserved++;
+        preservedList.push(targetRelPath); preserved++;
       }
     }
   }