@sandeco/antares 0.0.0-stage → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 sandeco
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,23 @@
-# Temporary Holding Version
+# Antares para alunos
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Na pasta do seu canal, use o comando recebido no curso:
+
+```powershell
+npx @sandeco/antares "<código>"
+```
+
+Requer Node.js 18.20 ou superior e internet. Não é necessário login no npm nem no GitHub.
+O npm pode perguntar se deseja obter o baixador na primeira execução; confirme.
+O instalador pergunta se instala o Mira junto (`--com-mira` / `--sem-mira` pulam a pergunta).
+
+```powershell
+npx @sandeco/antares "<código>" update            # atualiza skills e runtime; nunca toca em _antares/
+npx @sandeco/antares "<código>" doctor --online   # dependências, Mira, conexão, MCPs
+npx @sandeco/antares "<código>" --dir C:/meu-canal
+```
+
+O código não diferencia maiúsculas, acentos, vírgulas ou espaços. Ele é conferido localmente para abrir um pacote cifrado; não é enviado pela rede nem salvo pelo baixador. Como qualquer argumento de terminal, pode aparecer no histórico ou na lista de processos do seu sistema. Os agentes do Antares não estão neste pacote npm.
+
+O pacote aberto fica numa pasta temporária só durante o comando e é removido ao final. O que permanece no canal é o mesmo de sempre: `.claude/skills/antares*/`, `.agents/skills/antares*/`, `.antares/` e os dados em `_antares/`. Depois da instalação, abra a pasta no seu agente e chame o Antares (`/antares` no Claude Code, `$antares` no Codex, `antares` no Gemini CLI); o dia a dia não precisa de rede nem de código.
+
+Um código compartilhado permite instalar em qualquer máquina que o possua. Não há identificação de aluno, expiração ou bloqueio de cópias já instaladas. Guarde o comando na área da turma.

package/bin/antares.mjs

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import { rodar } from '../src/bootstrap.mjs';
+
+try {
+  const release = JSON.parse(fs.readFileSync(new URL('../release.json', import.meta.url), 'utf8'));
+  const { version } = JSON.parse(fs.readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
+  process.exitCode = await rodar(process.argv.slice(2), release, { versao: version });
+} catch (erro) {
+  console.error('Antares: ' + erro.message);
+  process.exitCode = 1;
+}

package/package.json

@@ -1,6 +1,11 @@
 {
   "name": "@sandeco/antares",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "description": "Instalador do Antares para alunos com código de acesso",
+  "type": "module",
+  "license": "MIT",
+  "engines": { "node": ">=18.20.0" },
+  "bin": { "antares": "bin/antares.mjs" },
+  "files": ["bin/", "src/", "release.json", "README.md", "LICENSE"],
+  "publishConfig": { "access": "public", "registry": "https://registry.npmjs.org/" }
+}

package/release.json

@@ -0,0 +1,6 @@
+{
+  "schema": 1,
+  "runtimeVersion": "0.2.2",
+  "url": "https://gist.githubusercontent.com/sandeco/92fff05210d9c96d12cabe3282be5c9e/raw/28c590e44fd14a3a4550f8c7b7c3c0b02ed31381/antares.enc.json",
+  "sha256": "8f3d085254182671ad32065cc6de5148a820da6b089cfccac016e0b42fb7670d"
+}

package/src/bootstrap.mjs

@@ -0,0 +1,110 @@
+// Baixador público do Antares: confere o código, baixa o pacote cifrado fixado na release,
+// abre em pasta temporária e chama o instalador privado (install, update ou doctor).
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import { LIMITE, abrir, normalizarCodigo } from './pacote.mjs';
+
+export const COMANDOS = ['install', 'update', 'doctor'];
+
+const AJUDA = `Antares: instalação com código do curso
+Uso: npx @sandeco/antares "<código>" [install|update|doctor] [opções]
+  install (padrão)  instala o Antares na pasta atual (--com-mira | --sem-mira)
+  update            atualiza skills e runtime; nunca toca em _antares/
+  doctor            confere dependências, Mira, conexão e MCPs (--online)
+Opções: --dir <pasta> para outra pasta.
+Node.js 18.20 ou superior. Não é necessário login no npm nem no GitHub.
+O código não é enviado pela rede nem salvo pelo baixador.
+`;
+
+export function interpretar(args, cwd = process.cwd()) {
+  if (!args.length || ['--help', '-h'].includes(args[0])) return { ajuda: true };
+  if (args[0] === '--version') return { versao: true };
+  const posicionais = [];
+  let i = 0;
+  for (; i < args.length && !args[i].startsWith('-'); i++) posicionais.push(args[i]);
+  if (posicionais.some(p => p.length > 1024 || /[\x00-\x1f\x7f]/.test(p))) throw new Error('Informe o código recebido no curso.');
+  const comando = posicionais.length > 1 && COMANDOS.includes(posicionais[posicionais.length - 1]) ? posicionais.pop() : 'install';
+  const codigo = normalizarCodigo(posicionais);
+  const opcoes = [];
+  let pasta = cwd;
+  let informada = false;
+  for (; i < args.length; i++) {
+    if (args[i] === '--dir' || args[i].startsWith('--dir=')) {
+      if (informada) throw new Error('Opção duplicada: dir');
+      informada = true;
+      const valor = args[i] === '--dir' ? args[++i] : args[i].slice('--dir='.length);
+      if (!valor || valor.startsWith('--')) throw new Error('Valor ausente: dir');
+      pasta = path.resolve(cwd, valor);
+    } else opcoes.push(args[i]);
+  }
+  return { codigo, comando, opcoes, pasta: path.resolve(pasta) };
+}
+
+export function validarRelease(release) {
+  if (release?.schema !== 1 || !/^\d+\.\d+\.\d+$/.test(release.runtimeVersion) || !/^[a-f0-9]{64}$/.test(release.sha256)) throw new Error('Release não configurada pelo mantenedor.');
+  let url;
+  try { url = new URL(release.url); } catch { throw new Error('Release não configurada pelo mantenedor.'); }
+  if (url.protocol !== 'https:' || url.hostname !== 'gist.githubusercontent.com' || url.port || url.username || url.password || url.search || url.hash || !/^\/[A-Za-z0-9-]+\/[a-f0-9]+\/raw\/[a-f0-9]{40}\/[A-Za-z0-9_.-]+$/.test(url.pathname)) throw new Error('Endereço da release inválido.');
+  return url.href;
+}
+
+export async function baixar(release, fetcher = fetch) {
+  const url = validarRelease(release);
+  const signal = AbortSignal.timeout(30_000);
+  const resposta = await fetcher(url, { redirect: 'error', signal, headers: { Accept: 'application/json' } });
+  if (!resposta.ok) throw new Error(`Download indisponível (HTTP ${resposta.status}). Tente novamente mais tarde.`);
+  const declarado = resposta.headers.get('content-length');
+  if (declarado !== null && (!/^\d+$/.test(declarado) || Number(declarado) > LIMITE)) throw new Error('Download excede o limite permitido.');
+  if (!resposta.body) throw new Error('Download vazio.');
+  const partes = [];
+  let tamanho = 0;
+  for await (const parte of resposta.body) {
+    tamanho += parte.length;
+    if (tamanho > LIMITE) throw new Error('Download excede o limite permitido.');
+    partes.push(parte);
+  }
+  return Buffer.concat(partes);
+}
+
+// Grava o pacote numa pasta temporária nova; quem chama remove ao terminar.
+export function materializar(pacote) {
+  const destino = fs.mkdtempSync(path.join(os.tmpdir(), 'antares-pacote-'));
+  for (const arquivo of pacote.files) {
+    const alvo = path.join(destino, arquivo.path);
+    fs.mkdirSync(path.dirname(alvo), { recursive: true });
+    fs.writeFileSync(alvo, arquivo.content, { flag: 'wx', mode: arquivo.mode });
+  }
+  return destino;
+}
+
+export function executar(runtime, comando, pasta, opcoes) {
+  return new Promise((resolve, reject) => {
+    const filho = spawn(process.execPath, [path.join(runtime, 'bin/antares.js'), comando, ...opcoes, '--dir', pasta], { cwd: process.cwd(), stdio: 'inherit', shell: false, windowsHide: true });
+    const int = () => filho.kill('SIGINT');
+    const term = () => filho.kill('SIGTERM');
+    process.on('SIGINT', int);
+    process.on('SIGTERM', term);
+    const limpar = () => { process.off('SIGINT', int); process.off('SIGTERM', term); };
+    filho.once('error', erro => { limpar(); reject(erro); });
+    filho.once('close', (codigo, sinal) => { limpar(); resolve(codigo ?? (sinal === 'SIGINT' ? 130 : 1)); });
+  });
+}
+
+export async function rodar(args, release, deps = {}) {
+  const p = interpretar(args, deps.cwd ?? process.cwd());
+  const log = deps.log ?? console.log;
+  if (p.ajuda) { log(AJUDA); return 0; }
+  if (p.versao) { log(deps.versao ?? '0.0.0'); return 0; }
+  if (Number(process.versions.node.split('.')[0]) < 18) throw new Error('Instale Node.js 18.20 ou superior.');
+  const bytes = await baixar(release, deps.fetcher);
+  const pacote = await abrir(bytes, p.codigo, release);
+  const runtime = materializar(pacote);
+  try {
+    log(`Antares: código aceito. Abrindo ${p.comando}…`);
+    return await (deps.executar ?? executar)(runtime, p.comando, p.pasta, p.opcoes);
+  } finally {
+    fs.rmSync(runtime, { recursive: true, force: true });
+  }
+}

package/src/pacote.mjs

@@ -0,0 +1,93 @@
+// Abertura e validação do pacote cifrado do Antares (AES-256-GCM, chave derivada por scrypt).
+import { createHash, createDecipheriv, scrypt as scryptCallback } from 'node:crypto';
+import { promisify } from 'node:util';
+import { gunzipSync } from 'node:zlib';
+
+export const LIMITE = 4 * 1024 * 1024;
+export const LIMITE_ABERTO = 8 * 1024 * 1024;
+export const KDF = Object.freeze({ N: 65536, r: 8, p: 1, maxmem: 128 * 1024 * 1024 });
+export const AAD = Buffer.from('antares:pacote:v1');
+export const NOME_PACOTE = 'antares-agents';
+export const hash = valor => createHash('sha256').update(valor).digest('hex');
+export const derivar = (chave, salt) => promisify(scryptCallback)(chave, salt, 32, KDF);
+const invalido = () => { throw new Error('Pacote de distribuição inválido.'); };
+
+// O código ignora maiúsculas, acentos, vírgulas e espaços: "Exemplo, Código, Exemplo"
+// vale o mesmo com ou sem aspas, em qualquer shell.
+export function normalizarCodigo(partes) {
+  const texto = Array.isArray(partes) ? partes.join(' ') : String(partes ?? '');
+  const codigo = texto.normalize('NFD').replace(/[̀-ͯ]/g, '').toLowerCase().replace(/[^a-z0-9]/g, '');
+  if (codigo.length < 12 || codigo.length > 1024) throw new Error('Informe o código recebido no curso.');
+  return codigo;
+}
+
+export function decode64(valor, tamanho) {
+  if (typeof valor !== 'string' || !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(valor)) invalido();
+  const bytes = Buffer.from(valor, 'base64');
+  if (tamanho !== undefined && bytes.length !== tamanho) invalido();
+  return bytes;
+}
+
+export function entradaSegura(relativo) {
+  if (typeof relativo !== 'string' || relativo.length > 240 || !relativo.length || relativo.includes('\\')) invalido();
+  const partes = relativo.split('/');
+  if (partes.some(p => !/^[a-zA-Z0-9_.-]+$/.test(p) || p === '.' || p === '..' || /[. ]$/.test(p) || /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/i.test(p))) invalido();
+  const raizes = ['LICENSE', 'README.md', 'package.json'];
+  if (!raizes.includes(relativo) && !/^(agents|bin|lib|templates|docs)\//.test(relativo) && !/^node_modules\/[a-z0-9_.-]+\/.+/.test(relativo)) invalido();
+  return relativo;
+}
+
+export function validarPacote(pacote, versao) {
+  if (pacote?.schema !== 1 || pacote.name !== NOME_PACOTE || pacote.version !== versao || !Array.isArray(pacote.files) || !pacote.files.length || pacote.files.length > 1000) invalido();
+  const vistos = new Set();
+  let total = 0;
+  const arquivos = pacote.files.map(arquivo => {
+    const relativo = entradaSegura(arquivo?.path), minusculo = relativo.toLowerCase();
+    if (vistos.has(minusculo)) invalido();
+    vistos.add(minusculo);
+    const conteudo = decode64(arquivo.content);
+    total += conteudo.length;
+    if (total > LIMITE_ABERTO || hash(conteudo) !== arquivo.sha256) invalido();
+    if (![0o644, 0o755].includes(arquivo.mode)) invalido();
+    return { path: relativo, content: conteudo, mode: arquivo.mode, sha256: arquivo.sha256 };
+  });
+  // Um arquivo não pode ser também um diretório ancestral de outro.
+  for (const nome of vistos) {
+    const partes = nome.split('/');
+    while (partes.length > 1) { partes.pop(); if (vistos.has(partes.join('/'))) invalido(); }
+  }
+  const manifesto = arquivos.find(a => a.path === 'package.json');
+  if (!manifesto || !arquivos.some(a => a.path === 'bin/antares.js')) invalido();
+  const pkg = JSON.parse(manifesto.content.toString('utf8'));
+  if (pkg.name !== pacote.name || pkg.version !== versao) invalido();
+  // Dependências de runtime vêm vendorizadas no pacote; nada além delas em node_modules/.
+  const dependencias = Object.keys(pkg.dependencies ?? {});
+  if (dependencias.some(dep => !vistos.has(`node_modules/${dep}/package.json`))) invalido();
+  for (const nome of vistos) {
+    const m = /^node_modules\/([^/]+)\//.exec(nome);
+    if (m && !dependencias.includes(m[1])) invalido();
+  }
+  return { ...pacote, files: arquivos };
+}
+
+export async function abrir(bytes, codigo, release) {
+  if (!Buffer.isBuffer(bytes) || bytes.length > LIMITE || hash(bytes) !== release.sha256) throw new Error('Integridade do download divergente; instalação cancelada.');
+  const envelope = JSON.parse(bytes.toString('utf8'));
+  if (envelope?.schema !== 1 || envelope.kdf !== 'scrypt-65536-8-1' || envelope.cipher !== 'aes-256-gcm') invalido();
+  const salt = decode64(envelope.salt, 32), iv = decode64(envelope.iv, 12), tag = decode64(envelope.tag, 16);
+  const cifrado = decode64(envelope.data);
+  let derivada;
+  let comprimido;
+  try {
+    derivada = await derivar(codigo, salt);
+    const decipher = createDecipheriv('aes-256-gcm', derivada, iv);
+    decipher.setAAD(AAD);
+    decipher.setAuthTag(tag);
+    comprimido = Buffer.concat([decipher.update(cifrado), decipher.final()]);
+  } catch {
+    throw new Error('Código de acesso inválido. Confira o comando recebido no curso.');
+  } finally { derivada?.fill(0); }
+  const aberto = gunzipSync(comprimido, { maxOutputLength: LIMITE_ABERTO });
+  try { return validarPacote(JSON.parse(aberto.toString('utf8')), release.runtimeVersion); }
+  finally { aberto.fill(0); comprimido.fill(0); }
+}