atris 3.82.14 → 3.82.16

package/bin/atris.js

@@ -153,7 +153,7 @@ const dryRunRequested = updateArgs.includes('--dry-run');
 const skipUpdateCheck = Boolean(process.env.ATRIS_SKIP_UPDATE_CHECK || process.env.NO_UPDATE_NOTIFIER || helpRequested || jsonRequested);
 // Local-only commands make no registry call and start no background install.
 // sentinel prints its own one-line notice at the end of the run instead.
-if (!skipUpdateCheck && (!updateCommand || (updateCommand && !['version', 'update', 'mcp', 'recap', '99', 'sentinel'].includes(updateCommand)))) {
+if (!skipUpdateCheck && (!updateCommand || (updateCommand && !['version', 'update', 'mcp', 'recap', '99', 'sentinel', 'login'].includes(updateCommand)))) {
   updateCheckPromise = checkForUpdates()
     .then((updateInfo) => {
       if (updateInfo) {
@@ -1047,7 +1047,7 @@ function showReleaseHelp() {
 
 function showAuthHelp(commandName) {
   const usage = {
-    login: 'Usage: atris login [--token <token>] [--force] [--agent] [--client-id <atc_...> --client-secret-file <path>]',
+    login: 'Usage: atris login [--code <code>] [--token <token>] [--force] [--agent] [--client-id <atc_...> --client-secret-file <path>]',
     logout: 'Usage: atris logout',
     whoami: 'Usage: atris whoami [--json]',
     switch: 'Usage: atris switch [account] [--global]',
@@ -1059,10 +1059,13 @@ function showAuthHelp(commandName) {
   console.log('');
   console.log('Description:');
   if (commandName === 'login') {
-    console.log('  Sign in with browser OAuth or a pasted API token.');
-    console.log('  --agent mints a scoped agent token from stored credentials. No browser.');
-    console.log('  --client-id signs an agent in by itself with an agent client (see atris agent-client).');
-    console.log('  The token renews on its own; the secret is never printed.');
+    console.log('  Pick the one that fits you:');
+    console.log('  A person: run atris login. It opens the browser, then you paste the one-time code.');
+    console.log('    No terminal? Open atris.ai/auth/cli and run atris login --code <code>.');
+    console.log('  An agent on its own: atris login --client-id <atc_...> --client-secret-file <path>.');
+    console.log('    Make the client once with atris agent-client. It renews itself and never prints the secret.');
+    console.log('  A script calling the API: atris login --token <atris_... key>.');
+    console.log('  The one-time code is not a token. If you paste it as one, login signs you in with it.');
   } else if (commandName === 'logout') {
     console.log('  Sign out of the current Atris account.');
   } else if (commandName === 'whoami') {
@@ -1077,6 +1080,7 @@ function showAuthHelp(commandName) {
   console.log('');
   console.log('Options:');
   if (commandName === 'login') {
+    console.log('  --code <code>             Sign in with the one-time code from atris.ai/auth/cli. --code - reads it from stdin.');
     console.log('  --token <token>           Save an API token without prompting.');
     console.log('  --force, -f               Re-run login even if credentials already exist.');
     console.log('  --agent                   Mint a scoped agent token from the stored login.');

package/commands/auth.js

@@ -622,6 +622,108 @@ async function loginAgentClient(request, deps = {}) {
   return 0;
 }
 
+// The browser page at /auth/cli shows a one-time code: secrets.token_urlsafe(32)
+// in the backend, so 43 url-safe characters with no dots. Tokens are JWTs
+// (three dot-joined parts) and API keys start with atris_. A code pasted where
+// a token belongs used to be saved as a token and fail later with a JWT error.
+const CLI_CODE_PATTERN = /^(?!atris_)[A-Za-z0-9_-]{43}$/;
+const CODE_NOT_TOKEN_NOTE = 'that is the one-time code from the browser, not a token. signing you in with it.';
+
+function looksLikeCliCode(value) {
+  return CLI_CODE_PATTERN.test(String(value || '').trim());
+}
+
+// readFlag treats a value starting with "-" as the next flag, but one code in
+// 64 starts with a dash. Take --code=<v> as is, and the next arg when it is
+// code-shaped or not a flag. "-" or nothing means read stdin.
+function readCodeFlag(args = []) {
+  const eq = args.find((arg) => String(arg).startsWith('--code='));
+  if (eq !== undefined) {
+    const value = String(eq).slice('--code='.length);
+    return value === '-' ? '' : value;
+  }
+  const next = args[args.indexOf('--code') + 1];
+  if (next === undefined || next === '-') return '';
+  if (looksLikeCliCode(next) || !String(next).startsWith('-')) return String(next);
+  return '';
+}
+
+function headlessLoginHelp() {
+  const url = `${getAppBaseUrl()}/auth/cli`;
+  return [
+    `open ${url}, sign in, then pass the one-time code it shows:`,
+    '  atris login --code <code>      or      echo <code> | atris login',
+    'agents without a person: atris login --client-id <atc_...> --client-secret-file <path>',
+  ];
+}
+
+// Reads a code piped into stdin. Only reads a pipe, socket, or file, and
+// gives up after a short wait so an open, silent stdin never hangs login.
+function readPipedLoginInput(timeoutMs = 1500) {
+  return new Promise((resolve) => {
+    let stat;
+    try { stat = fs.fstatSync(0); } catch { resolve(''); return; }
+    // Node-launched agents hand stdin over as a socket, shells as a FIFO.
+    if (!stat || !(stat.isFIFO() || stat.isFile() || stat.isSocket())) { resolve(''); return; }
+    let data = '';
+    let finished = false;
+    const finish = () => {
+      if (finished) return;
+      finished = true;
+      clearTimeout(timer);
+      process.stdin.removeAllListeners('data');
+      process.stdin.pause();
+      resolve(data.split(/\r?\n/).map((line) => line.trim()).find(Boolean) || '');
+    };
+    const timer = setTimeout(finish, timeoutMs);
+    if (timer.unref) timer.unref();
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (chunk) => {
+      data += chunk;
+      if (data.length > 8192 || /\n/.test(data)) finish();
+    });
+    process.stdin.on('end', finish);
+    process.stdin.on('error', finish);
+    process.stdin.resume();
+  });
+}
+
+async function exchangeCliCodeAndSave(code, { asJson = false, note = null, quiet = false } = {}) {
+  if (note && !asJson) console.log(note);
+  const exchange = await apiRequestJson('/auth/cli/exchange', {
+    method: 'POST',
+    body: { code: String(code).trim() },
+  });
+  const payload = exchange && exchange.ok ? exchange.data : null;
+  if (!payload || !payload.token || !payload.refresh_token) {
+    const error = !payload
+      ? (exchange && exchange.error) || 'invalid or expired code'
+      : 'the server did not return tokens. try again.';
+    const unreachable = !exchange || !exchange.status;
+    const next = unreachable
+      ? `could not reach ${getApiBaseUrl()}. check the connection and run the same command again.`
+      : `get a fresh code at ${getAppBaseUrl()}/auth/cli. codes last five minutes and work once.`;
+    if (asJson) {
+      console.log(JSON.stringify({ ok: false, logged_in: false, error, next }, null, 2));
+    } else {
+      console.error(`Error: ${error}`);
+      console.error(next);
+    }
+    return 1;
+  }
+  const email = payload.email || null;
+  saveCredentials(payload.token, payload.refresh_token, email, payload.user_id || null, payload.provider || 'atris');
+  if (quiet) return 0;
+  if (asJson) {
+    console.log(JSON.stringify({ ok: true, logged_in: true, email, user_id: payload.user_id || null, provider: payload.provider || 'atris', next: 'atris whoami --json' }, null, 2));
+    return 0;
+  }
+  const name = profileNameFromEmail(email);
+  console.log(`\n✓ Signed in as ${email || 'unknown'}${name ? ` (profile: ${name})` : ''}`);
+  await displayAccountSummary(apiRequestJson);
+  return 0;
+}
+
 async function loginAtris(options = {}) {
   // Support: atris login --token <token> --force
   const args = process.argv.slice(3);
@@ -645,7 +747,11 @@ async function loginAtris(options = {}) {
     const existing = loadCredentials();
 
     if (wantsAgentToken(args)) {
-      if (directToken) {
+      if (directToken && looksLikeCliCode(directToken)) {
+        // sign in with the code first, then mint from that real login
+        const exchanged = await exchangeCliCodeAndSave(directToken, { asJson, note: CODE_NOT_TOKEN_NOTE, quiet: true });
+        if (exchanged !== 0) process.exit(exchanged);
+      } else if (directToken) {
         saveCredentials(
           String(directToken).trim(),
           existing?.refresh_token || null,
@@ -658,7 +764,26 @@ async function loginAtris(options = {}) {
       process.exit(code);
     }
 
+    // One-time code from the browser, no prompt: --code <code>, --code=<code>,
+    // or --code - to read it from stdin. An explicit code means sign in now,
+    // even over an existing login.
+    const codeFlagPresent = args.some((arg) => arg === '--code' || String(arg).startsWith('--code='));
+    if (codeFlagPresent) {
+      let code = readCodeFlag(args);
+      if (!code) code = await readPipedLoginInput(5000);
+      if (!code) {
+        const error = 'no code given.';
+        if (asJson) console.log(JSON.stringify({ ok: false, logged_in: false, error, next: 'atris login --code <code>' }, null, 2));
+        else { console.error(`Error: ${error}`); headlessLoginHelp().forEach((line) => console.error(line)); }
+        process.exit(1);
+      }
+      process.exit(await exchangeCliCodeAndSave(code, { asJson }));
+    }
+
     // Direct token mode (non-interactive)
+    if (directToken && looksLikeCliCode(directToken)) {
+      process.exit(await exchangeCliCodeAndSave(directToken, { asJson, note: CODE_NOT_TOKEN_NOTE }));
+    }
     if (directToken) {
       const trimmed = directToken.trim();
       saveCredentials(trimmed, null, existing?.email || null, existing?.user_id || null, existing?.provider || 'manual');
@@ -675,6 +800,13 @@ async function loginAtris(options = {}) {
       process.exit(0);
     }
 
+    // echo <code> | atris login signs in with no terminal, over an existing
+    // login too. Read once here so the shortcut below cannot swallow it.
+    const piped = (!process.stdin.isTTY && !directToken) ? await readPipedLoginInput() : '';
+    if (piped && looksLikeCliCode(piped)) {
+      process.exit(await exchangeCliCodeAndSave(piped, { asJson }));
+    }
+
     // Already signed in without --force: behave like whoami (no menu).
     // Print local identity without waiting on the network so headless agents
     // never hang on a stale token validation.
@@ -706,13 +838,17 @@ async function loginAtris(options = {}) {
         console.log(JSON.stringify({
           ok: false,
           logged_in: false,
-          error: 'login requires --token in non-interactive mode',
-          next: 'atris login --token <token>',
+          error: piped
+            ? 'what came in on stdin is not a one-time code from the browser'
+            : 'login has no terminal here. pass the one-time code from the browser.',
+          next: 'atris login --code <code>',
+          code_url: `${getAppBaseUrl()}/auth/cli`,
+          agents: 'atris login --client-id <atc_...> --client-secret-file <path>',
         }, null, 2));
       } else {
         console.log('Not signed in.');
-        console.log('login needs a terminal for browser OAuth, or pass a token.');
-        console.log('Next: atris login --token <token>');
+        if (piped) console.log('what came in on stdin is not a one-time code from the browser. for an API token use --token.');
+        headlessLoginHelp().forEach((line) => console.log(line));
       }
       process.exit(1);
     }
@@ -723,7 +859,7 @@ async function loginAtris(options = {}) {
 
     console.log('Choose login method:');
     console.log('  1. Browser OAuth (recommended)');
-    console.log('  2. Paste existing API token');
+    console.log('  2. Paste an API token');
     console.log('  3. Cancel');
 
     const methodChoice = await promptUser('\nEnter choice (1-3): ');
@@ -743,39 +879,17 @@ async function loginAtris(options = {}) {
         process.exit(1);
       }
 
-      const exchange = await apiRequestJson('/auth/cli/exchange', {
-        method: 'POST',
-        body: { code: code.trim() },
-      });
-
-      if (!exchange.ok || !exchange.data) {
-        console.error(`Error: ${exchange.error || 'Invalid or expired code'}`);
-        process.exit(1);
-      }
-
-      const payload = exchange.data;
-      const token = payload.token;
-      const refreshToken = payload.refresh_token;
-
-      if (!token || !refreshToken) {
-        console.error('Error: Backend did not return tokens. Try again.');
-        process.exit(1);
-      }
-
-      const email = payload.email || null;
-      const userId = payload.user_id || null;
-      const provider = payload.provider || 'atris';
-
-      saveCredentials(token, refreshToken, email, userId, provider);
-      const name = profileNameFromEmail(email);
-      console.log(`\n✓ Signed in as ${email || 'unknown'}${name ? ` (profile: ${name})` : ''}`);
-      await displayAccountSummary(apiRequestJson);
-      process.exit(0);
+      process.exit(await exchangeCliCodeAndSave(code));
     } else if (methodChoice === '2') {
-      console.log('\nGet your token from: https://atris.ai/auth/cli\n');
+      console.log('\nPaste an API token (starts with atris_) or a saved session token.');
+      console.log('The one-time code from the browser works here too.\n');
 
       const tokenInput = await promptUser('API token: ', { secret: true });
 
+      if (tokenInput && looksLikeCliCode(tokenInput)) {
+        process.exit(await exchangeCliCodeAndSave(tokenInput, { note: CODE_NOT_TOKEN_NOTE }));
+      }
+
       if (!tokenInput) {
         console.error('Error: Token is required.');
         process.exit(1);

package/commands/business.js

@@ -52,38 +52,38 @@ const {
   findAtrisDir,
 } = require('../lib/business-core');
 
-async function findExistingBusinessBySlug(slug, token) {
+async function findExistingBusinessBySlug(slug, token, { api = apiRequestJson, loadLocal = loadBusinesses } = {}) {
   if (!slug) return null;
 
-  // Local cache first, no network round-trip needed.
-  const local = loadBusinesses();
-  if (local[slug]) {
-    return { id: local[slug].business_id, name: local[slug].name, slug, source: 'local' };
-  }
-  for (const v of Object.values(local)) {
-    if (businessMatchesSlug(v, slug)) {
-      return { id: v.business_id, name: v.name, slug, source: 'local' };
-    }
-  }
+  const local = loadLocal();
+  const localMatch = local[slug]
+    ? { id: local[slug].business_id, name: local[slug].name, slug, source: 'local' }
+    : (() => {
+      const v = Object.values(local).find((b) => businessMatchesSlug(b, slug));
+      return v ? { id: v.business_id, name: v.name, slug, source: 'local' } : null;
+    })();
 
-  if (!token) return null;
+  if (!token) return localMatch;
 
-  // Cloud lookup, covers businesses the user is a member of but hasn't added.
-  const direct = await apiRequestJson(`/business/by-slug/${encodeURIComponent(slug)}`, {
-    method: 'GET',
-    token,
-  });
+  // The cloud is the truth. The Mac's list can hold a business that was
+  // deleted, and trusting it refused to recreate one that no longer existed.
+  const direct = await api(`/business/by-slug/${encodeURIComponent(slug)}`, { method: 'GET', token });
   if (direct.ok && direct.data && direct.data.id) {
     return { id: direct.data.id, name: direct.data.name, slug: direct.data.slug || slug, source: 'cloud' };
   }
 
-  const list = await apiRequestJson('/business/', { method: 'GET', token });
+  const list = await api('/business/', { method: 'GET', token });
   if (list.ok && Array.isArray(list.data)) {
     const match = list.data.find(b => businessMatchesSlug(b, slug));
     if (match) return { id: match.id, name: match.name, slug: match.slug, source: 'cloud' };
+    if (localMatch) {
+      console.warn(`  Note: this Mac still lists "${slug}", but the cloud has no such business. Run: atris business doctor --fix`);
+    }
+    return null;
   }
 
-  return null;
+  // Cloud unreachable: fall back to the Mac's list rather than risk a duplicate.
+  return localMatch;
 }
 
 async function addBusiness(slug) {
@@ -1665,6 +1665,7 @@ async function businessCommand(subcommand, ...args) {
 }
 
 module.exports = {
+  findExistingBusinessBySlug,
   businessCommand,
   businessWorkspaceBase,
   loadBusinesses,

package/commands/memory-live.js

@@ -1,6 +1,6 @@
 'use strict';
 
-// atris memory show, search, read, ls, remember, write, rm, usage, log, lesson
+// atris memory show, search, ask, read, ls, remember, write, rm, usage, log, lesson
 // and agents: the person's Atris memory from any terminal, so any agent can
 // read it, search it and save to it. One request per command. The login and
 // network modules load only when a command needs the server.
@@ -13,6 +13,7 @@ const { NOT_LOGGED_IN, oneLine, tokenFrom } = require('../lib/developer-api');
 const MAX_WRITE_BYTES = 1000000;
 const STDIN_WAIT_MS = 5000;
 const REMEMBER_MAX_CHARS = 1000;
+const ASK_MAX_CHARS = 500;
 const REMEMBER_FILES = ['journal', 'now', 'learning'];
 const LEARNING_SECTIONS = ['want', 'understand', 'shaky'];
 
@@ -138,6 +139,20 @@ const COMMANDS = {
     },
   },
 
+  ask: {
+    check(ctx) {
+      const question = ctx.words.join(' ').replace(/\s+/g, ' ').trim();
+      if (!question) throw new UsageError('ask a question, like atris memory ask "where does Sam work?"');
+      if (question.length > ASK_MAX_CHARS) throw new UsageError('keep the question under 500 characters');
+      return { question, folder: ctx.flags['--in'] || '' };
+    },
+    async run(ctx, { question, folder }) {
+      // The server reads for up to 75 seconds; asking twice would count twice.
+      const data = await ctx.call(`/memory/ask?q=${enc(question)}${folder ? `&folder=${enc(folder)}` : ''}`, { timeoutMs: 90000, retries: 0 });
+      return { data, lines: live.askLines(data) };
+    },
+  },
+
   read: {
     check(ctx) {
       const rel = onePath(ctx, 'file to read');

package/commands/push.js

@@ -9,6 +9,17 @@ const { normalizeWikiOnlyPrefix } = require('../lib/wiki');
 const { emitSyncEvent, startTimer } = require('../lib/sync-telemetry');
 const { assertSafeWorkspaceRoot } = require('../lib/workspace-safety');
 
+// The server's own words for a refused request. It used to be dropped, so a
+// refusal for any reason read as "you can only push to your team/ folder".
+function refusalText(result) {
+  if (!result) return '';
+  const raw = result.errorMessage || result.error || (result.data && result.data.detail) || '';
+  if (!raw) return '';
+  if (typeof raw === 'string') return raw === 'Request failed' ? '' : raw;
+  if (typeof raw === 'object' && typeof raw.message === 'string') return raw.message;
+  try { return JSON.stringify(raw); } catch { return String(raw); }
+}
+
 function resolvePushSourceDir({ slug, argv = process.argv, cwd = process.cwd() }) {
   const fromIdx = argv.indexOf('--from');
   if (fromIdx !== -1 && argv[fromIdx + 1]) {
@@ -858,13 +869,15 @@ async function pushAtris() {
               pushed = landedPaths.size;
               break;
             } else {
-              console.error(`\n  Push failed: ${retry.errorMessage || retry.error || retry.status}`);
+              console.error(`\n  Push failed: ${refusalText(retry) || retry.status}`);
+              if (refusalText(result)) console.error(`  The first refusal said: ${refusalText(result)}`);
               await emit('access_denied', { error_detail: `403 retry failed: ${retry.status}` });
               process.exit(1);
             }
           } else {
-            console.error('\n  Access denied: you can only push to your team/ folder.');
-            await emit('access_denied');
+            const reason = refusalText(result);
+            console.error(`\n  Access denied: ${reason || 'the server refused this push and gave no reason.'}`);
+            await emit('access_denied', reason ? { error_detail: reason } : undefined);
             process.exit(1);
           }
         } else if (result.status === 409) {
@@ -1052,6 +1065,7 @@ async function pushAtris() {
 }
 
 module.exports = {
+  refusalText,
   pushAtris,
   buildPushChangePlan,
   buildPushUploadBatches,

package/lib/memory-live.js

@@ -9,7 +9,7 @@ const fs = require('fs');
 const path = require('path');
 
 const LIVE_COMMANDS = new Set([
-  'show', 'search', 'read', 'ls', 'remember', 'write', 'rm', 'usage', 'log', 'lesson', 'agents', 'setup',
+  'show', 'search', 'ask', 'read', 'ls', 'remember', 'write', 'rm', 'usage', 'log', 'lesson', 'agents', 'setup',
 ]);
 
 function isLiveCommand(word) {
@@ -19,10 +19,11 @@ function isLiveCommand(word) {
 // One line per command, shown together by `atris memory` and one at a time by
 // `atris memory <command> --help`.
 const COLUMN = 38;
-const row = (form, ...what) => [`  ${form}`.padEnd(COLUMN) + what[0], ...what.slice(1).map((more) => ' '.repeat(COLUMN) + more)].join('\n');
+const row = (form, ...what) => [`  ${form} `.padEnd(COLUMN) + what[0], ...what.slice(1).map((more) => ' '.repeat(COLUMN) + more)].join('\n');
 const USAGE_LINES = {
   show: row('show', 'who they are and what matters now; read it before helping'),
   search: row('search "rent|lease" [--in folder]', 'lines with any of the words, split by |'),
+  ask: row('ask "a question" [--in folder]', 'answered from their memory, with the lines it rests on'),
   read: row('read <path> [--from N] [--lines N]', 'numbered lines of one file; --raw prints it as stored'),
   ls: row('ls [folder]', 'what is in a folder; MAP.md says what is where'),
   remember: row('remember "one short line"', 'a lasting fact or preference about the person, when they',
@@ -43,6 +44,7 @@ const LIVE_HELP = [
   'read',
   USAGE_LINES.show,
   USAGE_LINES.search,
+  USAGE_LINES.ask,
   USAGE_LINES.read,
   USAGE_LINES.ls,
   '',
@@ -62,6 +64,7 @@ const LIVE_HELP = [
 // Flags that take a value, per command. --json, --raw and --help take none.
 const VALUE_FLAGS = {
   search: ['--in'],
+  ask: ['--in'],
   read: ['--from', '--lines'],
   ls: [],
   show: [],
@@ -205,6 +208,26 @@ function searchLines(query, data) {
   return lines;
 }
 
+// The answer first, then each line it rests on, then how sure it is. With no
+// answer (the model was busy) the search hits it started from are shown.
+function askLines(data) {
+  const sources = (data && data.sources) || [];
+  const cite = sources.map((s) => `  ${s.path}:${s.n}: ${s.text}`);
+  if (data && data.answer && data.found) {
+    return [String(data.answer), ...(cite.length ? ['', 'From:', ...cite] : [])];
+  }
+  if (data && data.answer) {
+    const lines = [String(data.answer)];
+    if (cite.length) lines.push('', 'Closest lines:', ...cite);
+    lines.push('', 'Not found for certain. Search it yourself: atris memory search "word|other word"');
+    return lines;
+  }
+  const hits = (data && data.search && data.search.hits) || [];
+  const lines = [String((data && data.note) || 'No answer right now.')];
+  if (hits.length) lines.push('', 'Lines that may hold it:', ...hits.slice(0, 8).map((h) => `  ${h.path}:${h.n}: ${h.text}`));
+  return lines;
+}
+
 function readLines(data) {
   const page = (data && data.lines) || [];
   const total = Number(data && data.total) || 0;
@@ -244,7 +267,7 @@ function rulesBlock(agent) {
     '',
     'This person keeps one memory in Atris that every app and agent shares. Use it.',
     '- Start each task with `atris memory show`: who they are and what matters now.',
-    '- Before you ask them anything they may have said before, search: `atris memory search "word|other word"`.',
+    '- Before you ask them anything they may have said before, search: `atris memory search "word|other word"`, or ask in plain words: `atris memory ask "..."`.',
     '- Open what you find with `atris memory read <path>`. `atris memory ls` shows the folder.',
     '- When they say remember, note, save or don\'t forget, save one short line: `atris memory remember "..."`.',
     '- Save only lasting facts about them, never logs or your own work. Never rewrite their about.md.',
@@ -338,6 +361,7 @@ module.exports = {
   END,
   LIVE_HELP,
   USAGE_LINES,
+  askLines,
   isLiveCommand,
   lsLines,
   mcpLines,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atris",
-  "version": "3.82.14",
+  "version": "3.82.16",
   "description": "you say what you want in plain words. atris builds it, checks it, and shows you proof. project memory your coding agents share across sessions.",
   "mcpName": "io.github.atrislabs/atris",
   "main": "bin/atris.js",