@jaimevalasek/aioson 1.7.0 → 1.8.0

package/src/commands/store-genome.js

@@ -0,0 +1,304 @@
+'use strict';
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const { exists } = require('../utils');
+const { readConfig } = require('./config');
+const { readWorkspace, findProjectRoot } = require('./workspace');
+const { scanPackage, formatScanReport } = require('../lib/store/security-scan');
+
+const DEFAULT_BASE_URL = 'https://aioson.com';
+const GENOMES_DIR = '.aioson/genomes';
+
+function resolveBaseUrl(config) {
+  return String(config.aiosonBaseUrl || DEFAULT_BASE_URL).replace(/\/+$/, '');
+}
+
+function requireToken(config, t) {
+  const token = config.aiosonToken;
+  if (!token) throw new Error(t('store.error_not_authenticated'));
+  return token;
+}
+
+async function storeGet(url, token) {
+  const response = await fetch(url, {
+    headers: {
+      authorization: `Bearer ${token}`,
+      accept: 'application/json'
+    },
+    signal: AbortSignal.timeout(15000)
+  });
+  const text = await response.text();
+  let parsed = null;
+  try { parsed = JSON.parse(text); } catch { /* */ }
+  if (!response.ok) {
+    const detail = (parsed && parsed.error) ? String(parsed.error) : `${response.status} ${response.statusText}`;
+    throw new Error(`HTTP ${response.status}: ${detail}`);
+  }
+  return parsed;
+}
+
+async function storePost(url, payload, token) {
+  const response = await fetch(url, {
+    method: 'POST',
+    headers: {
+      authorization: `Bearer ${token}`,
+      'content-type': 'application/json',
+      accept: 'application/json'
+    },
+    body: JSON.stringify(payload),
+    signal: AbortSignal.timeout(30000)
+  });
+
+  const text = await response.text();
+  let parsed = null;
+  try { parsed = JSON.parse(text); } catch { /* */ }
+
+  if (!response.ok) {
+    const detail = (parsed && parsed.error) ? String(parsed.error) : `${response.status} ${response.statusText}`;
+    throw new Error(`HTTP ${response.status}: ${detail}`);
+  }
+
+  return parsed;
+}
+
+async function collectRefs(refsDir) {
+  const refs = {};
+  if (!(await exists(refsDir))) return refs;
+  const entries = await fs.readdir(refsDir);
+  for (const entry of entries) {
+    try {
+      refs[entry] = await fs.readFile(path.join(refsDir, entry), 'utf8');
+    } catch { /* */ }
+  }
+  return refs;
+}
+
+// ── genome:publish ──────────────────────────────────────────────────────────
+
+async function runGenomePublish({ args, options, logger, t }) {
+  const config = await readConfig();
+  const token = requireToken(config, t);
+  const projectDir = await findProjectRoot(path.resolve(process.cwd(), args[0] || '.'));
+  const slug = String(options.slug || '').trim();
+  if (!slug) throw new Error(t('store.error_missing_slug'));
+
+  const genomePath = path.join(projectDir, GENOMES_DIR, `${slug}.md`);
+  const metaPath = path.join(projectDir, GENOMES_DIR, `${slug}.meta.json`);
+  const refsDir = path.join(projectDir, GENOMES_DIR, `${slug}.refs`);
+
+  if (!(await exists(genomePath))) {
+    throw new Error(t('store.error_genome_not_found', { slug, path: genomePath }));
+  }
+
+  logger.log(t('store.publish_genome_validating'));
+  const content = await fs.readFile(genomePath, 'utf8');
+
+  let meta = {};
+  if (await exists(metaPath)) {
+    try { meta = JSON.parse(await fs.readFile(metaPath, 'utf8')); } catch { /* */ }
+  }
+
+  const refs = await collectRefs(refsDir);
+
+  // Security scan
+  const allFiles = { [`${slug}.md`]: content };
+  if (meta) allFiles[`${slug}.meta.json`] = JSON.stringify(meta);
+  for (const [k, v] of Object.entries(refs)) allFiles[`refs/${k}`] = v;
+
+  const scan = scanPackage(allFiles, 'genome');
+  formatScanReport(scan, logger);
+  if (!scan.ok) throw new Error(t('store.error_scan_failed'));
+  if (scan.warnings.length > 0 && !options.force) {
+    throw new Error(t('store.error_scan_warnings', { count: scan.warnings.length }));
+  }
+
+  const ws = await readWorkspace(projectDir);
+  const visibility = options.private ? 'private' : 'public';
+  const paid = Boolean(options.paid);
+
+  if (options['dry-run']) {
+    logger.log(t('store.publish_dry_run', { type: 'genome', slug, visibility }));
+    logger.log(t('store.publish_scan_ok', { hash: scan.hash.slice(0, 12) }));
+    return { ok: true, dryRun: true, slug, visibility, paid, hash: scan.hash };
+  }
+
+  logger.log(t('store.publish_scan_ok', { hash: scan.hash.slice(0, 12) }));
+  logger.log(t('store.publish_genome_sending'));
+  const baseUrl = resolveBaseUrl(config);
+  const response = await storePost(`${baseUrl}/api/store/genomes/publish`, {
+    kind: 'aioson.store.genome',
+    slug,
+    content,
+    meta,
+    refs,
+    visibility,
+    paid,
+    hash: scan.hash,
+    workspaceSlug: ws?.slug || null
+  }, token);
+
+  logger.log(t('store.publish_genome_done', { slug, url: `${baseUrl}/store/genomes/${slug}` }));
+  return { ok: true, slug, visibility, paid, response };
+}
+
+// ── genome:install (store) ──────────────────────────────────────────────────
+
+async function runGenomeInstallStore({ args, options, logger, t }) {
+  const config = await readConfig();
+  const token = requireToken(config, t);
+  const projectDir = await findProjectRoot(path.resolve(process.cwd(), args[0] || '.'));
+  const baseUrl = resolveBaseUrl(config);
+
+  // Accept: --slug=X or positional code/slug
+  const ref = String(options.slug || options.code || args[1] || args[0] || '').trim();
+  if (!ref) throw new Error(t('store.error_missing_code_or_slug'));
+
+  const ws = await readWorkspace(projectDir);
+  logger.log(t('store.install_genome_fetching', { ref }));
+
+  const response = await storePost(`${baseUrl}/api/store/genomes/install`, {
+    ref,
+    workspaceSlug: ws?.slug || null
+  }, token);
+
+  const slug = response.slug;
+  if (!slug || !response.content) {
+    throw new Error(t('store.error_invalid_response'));
+  }
+
+  const destPath = path.join(projectDir, GENOMES_DIR, `${slug}.md`);
+  const metaDestPath = path.join(projectDir, GENOMES_DIR, `${slug}.meta.json`);
+
+  // Backup existing version if present
+  if ((await exists(destPath)) && !options.force) {
+    const backupPath = path.join(projectDir, GENOMES_DIR, `${slug}.backup.md`);
+    logger.log(t('store.install_backing_up', { path: backupPath }));
+    await fs.copyFile(destPath, backupPath);
+  }
+
+  await fs.mkdir(path.dirname(destPath), { recursive: true });
+  await fs.writeFile(destPath, response.content, 'utf8');
+
+  if (response.meta) {
+    await fs.writeFile(metaDestPath, `${JSON.stringify(response.meta, null, 2)}\n`, 'utf8');
+  }
+
+  // Write refs if present
+  if (response.refs && typeof response.refs === 'object') {
+    const refsDir = path.join(projectDir, GENOMES_DIR, `${slug}.refs`);
+    await fs.mkdir(refsDir, { recursive: true });
+    for (const [name, content] of Object.entries(response.refs)) {
+      await fs.writeFile(path.join(refsDir, name), content, 'utf8');
+    }
+  }
+
+  logger.log(t('store.install_genome_done', { slug, path: destPath }));
+  return { ok: true, slug, path: destPath };
+}
+
+// ── genome:install (user-facing alias for genome:install:store) ─────────────
+
+async function runGenomeInstall({ args, options, logger, t }) {
+  // Accept: aioson genome:install <code-or-slug> or --slug=X or --code=X
+  const ref = String(options.slug || options.code || args[0] || '').trim();
+  if (!ref) throw new Error(t('store.error_missing_code_or_slug'));
+  return runGenomeInstallStore({ args, options: { ...options, slug: ref }, logger, t });
+}
+
+// ── genome:list ─────────────────────────────────────────────────────────────
+
+async function runGenomeList({ args, options, logger, t }) {
+  // --remote: list published genomes on aioson.com
+  if (options.remote) {
+    const config = await readConfig();
+    const token = requireToken(config, t);
+    const baseUrl = resolveBaseUrl(config);
+    logger.log(t('store.list_remote_fetching', { type: 'genomes' }));
+    const response = await storeGet(`${baseUrl}/api/store/genomes`, token);
+    const genomes = response.genomes || [];
+    if (genomes.length === 0) {
+      logger.log(t('store.list_remote_empty', { type: 'genomes' }));
+    } else {
+      logger.log(t('store.list_remote_header', { count: genomes.length, type: 'genomes' }));
+      for (const g of genomes) {
+        logger.log(t('store.list_remote_item', { slug: g.slug, name: g.name || g.slug, visibility: g.visibility || '?' }));
+      }
+    }
+    return { ok: true, genomes, remote: true };
+  }
+
+  // local list
+  const projectDir = await findProjectRoot(path.resolve(process.cwd(), args[0] || '.'));
+  const genomesDir = path.join(projectDir, GENOMES_DIR);
+
+  if (!(await exists(genomesDir))) {
+    logger.log(t('store.list_genome_empty'));
+    return { ok: true, genomes: [] };
+  }
+
+  const entries = await fs.readdir(genomesDir);
+  const genomes = [];
+
+  for (const entry of entries) {
+    if (!entry.endsWith('.md') || entry.endsWith('.backup.md')) continue;
+    const slug = entry.replace(/\.md$/, '');
+    const metaPath = path.join(genomesDir, `${slug}.meta.json`);
+    let meta = {};
+    try {
+      if (await exists(metaPath)) {
+        meta = JSON.parse(await fs.readFile(metaPath, 'utf8'));
+      }
+    } catch { /* */ }
+    genomes.push({ slug, version: meta.version || null, name: meta.name || slug });
+  }
+
+  if (genomes.length === 0) {
+    logger.log(t('store.list_genome_empty'));
+  } else {
+    logger.log(t('store.list_genome_header', { count: genomes.length }));
+    for (const g of genomes) {
+      const ver = g.version ? ` (v${g.version})` : '';
+      logger.log(t('store.list_genome_item', { slug: g.slug, name: g.name, version: ver }));
+    }
+  }
+
+  return { ok: true, genomes };
+}
+
+// ── genome:remove ────────────────────────────────────────────────────────────
+
+async function runGenomeRemove({ args, options, logger, t }) {
+  const projectDir = await findProjectRoot(path.resolve(process.cwd(), args[0] || '.'));
+  const slug = String(options.slug || args[0] || '').trim();
+  if (!slug) throw new Error(t('store.error_missing_slug'));
+
+  const genomesDir = path.join(projectDir, GENOMES_DIR);
+  const genomePath = path.join(genomesDir, `${slug}.md`);
+  const metaPath = path.join(genomesDir, `${slug}.meta.json`);
+  const refsDir = path.join(genomesDir, `${slug}.refs`);
+
+  if (!(await exists(genomePath))) {
+    throw new Error(t('store.error_genome_not_found', { slug, path: genomePath }));
+  }
+
+  if (!options.force) {
+    // Backup before removing
+    const backupPath = path.join(genomesDir, `${slug}.backup.md`);
+    await fs.copyFile(genomePath, backupPath);
+    logger.log(t('store.install_backing_up', { path: backupPath }));
+  }
+
+  await fs.unlink(genomePath);
+  if (await exists(metaPath)) await fs.unlink(metaPath);
+  if (await exists(refsDir)) {
+    const refs = await fs.readdir(refsDir);
+    for (const r of refs) await fs.unlink(path.join(refsDir, r));
+    await fs.rmdir(refsDir);
+  }
+
+  logger.log(t('store.remove_genome_done', { slug }));
+  return { ok: true, slug };
+}
+
+module.exports = { runGenomePublish, runGenomeInstallStore, runGenomeInstall, runGenomeList, runGenomeRemove };

package/src/commands/store-skill.js

@@ -0,0 +1,247 @@
+'use strict';
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const { exists } = require('../utils');
+const { readConfig } = require('./config');
+const { readWorkspace, findProjectRoot } = require('./workspace');
+const { scanPackage, formatScanReport } = require('../lib/store/security-scan');
+
+const DEFAULT_BASE_URL = 'https://aioson.com';
+const SKILLS_DIRS = ['.aioson/skills', '.aioson/installed-skills'];
+
+function resolveBaseUrl(config) {
+  return String(config.aiosonBaseUrl || DEFAULT_BASE_URL).replace(/\/+$/, '');
+}
+
+function requireToken(config, t) {
+  const token = config.aiosonToken;
+  if (!token) throw new Error(t('store.error_not_authenticated'));
+  return token;
+}
+
+async function storeGet(url, token) {
+  const response = await fetch(url, {
+    headers: { authorization: `Bearer ${token}`, accept: 'application/json' },
+    signal: AbortSignal.timeout(15000)
+  });
+  const text = await response.text();
+  let parsed = null;
+  try { parsed = JSON.parse(text); } catch { /* */ }
+  if (!response.ok) {
+    const detail = (parsed && parsed.error) ? String(parsed.error) : `${response.status} ${response.statusText}`;
+    throw new Error(`HTTP ${response.status}: ${detail}`);
+  }
+  return parsed;
+}
+
+async function storePost(url, payload, token) {
+  const response = await fetch(url, {
+    method: 'POST',
+    headers: {
+      authorization: `Bearer ${token}`,
+      'content-type': 'application/json',
+      accept: 'application/json'
+    },
+    body: JSON.stringify(payload),
+    signal: AbortSignal.timeout(30000)
+  });
+
+  const text = await response.text();
+  let parsed = null;
+  try { parsed = JSON.parse(text); } catch { /* */ }
+
+  if (!response.ok) {
+    const detail = (parsed && parsed.error) ? String(parsed.error) : `${response.status} ${response.statusText}`;
+    throw new Error(`HTTP ${response.status}: ${detail}`);
+  }
+
+  return parsed;
+}
+
+/**
+ * Collect all files in a skill directory recursively.
+ * Returns { relativePath: fileContent } for text files.
+ */
+async function collectSkillFiles(skillDir) {
+  const files = {};
+
+  async function walk(dir, base) {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      const relPath = base ? `${base}/${entry.name}` : entry.name;
+      if (entry.isDirectory()) {
+        await walk(fullPath, relPath);
+      } else {
+        try {
+          files[relPath] = await fs.readFile(fullPath, 'utf8');
+        } catch { /* binary files skipped */ }
+      }
+    }
+  }
+
+  await walk(skillDir, '');
+  return files;
+}
+
+async function findSkillDir(projectDir, slug) {
+  for (const base of SKILLS_DIRS) {
+    const skillDir = path.join(projectDir, base, slug);
+    if (await exists(path.join(skillDir, 'SKILL.md'))) {
+      return skillDir;
+    }
+  }
+  return null;
+}
+
+// ── skill:publish ───────────────────────────────────────────────────────────
+
+async function runSkillPublish({ args, options, logger, t }) {
+  const config = await readConfig();
+  const token = requireToken(config, t);
+  const projectDir = await findProjectRoot(path.resolve(process.cwd(), args[0] || '.'));
+  const slug = String(options.slug || '').trim();
+  if (!slug) throw new Error(t('store.error_missing_slug'));
+
+  const skillDir = await findSkillDir(projectDir, slug);
+  if (!skillDir) {
+    throw new Error(t('store.error_skill_not_found', { slug }));
+  }
+
+  logger.log(t('store.publish_skill_collecting'));
+  const files = await collectSkillFiles(skillDir);
+  const fileCount = Object.keys(files).length;
+
+  if (!files['SKILL.md']) {
+    throw new Error(t('store.error_skill_missing_skillmd', { slug }));
+  }
+
+  // Security scan
+  const scan = scanPackage(files, 'skill');
+  formatScanReport(scan, logger);
+  if (!scan.ok) throw new Error(t('store.error_scan_failed'));
+  if (scan.warnings.length > 0 && !options.force) {
+    throw new Error(t('store.error_scan_warnings', { count: scan.warnings.length }));
+  }
+
+  const ws = await readWorkspace(projectDir);
+  const visibility = options.private ? 'private' : 'public';
+  const paid = Boolean(options.paid);
+
+  if (options['dry-run']) {
+    logger.log(t('store.publish_dry_run', { type: 'skill', slug, visibility }));
+    logger.log(t('store.publish_skill_files', { count: fileCount }));
+    logger.log(t('store.publish_scan_ok', { hash: scan.hash.slice(0, 12) }));
+    return { ok: true, dryRun: true, slug, visibility, paid, fileCount, hash: scan.hash };
+  }
+
+  logger.log(t('store.publish_scan_ok', { hash: scan.hash.slice(0, 12) }));
+  logger.log(t('store.publish_skill_sending', { count: fileCount }));
+  const baseUrl = resolveBaseUrl(config);
+  const response = await storePost(`${baseUrl}/api/store/skills/publish`, {
+    kind: 'aioson.store.skill',
+    slug,
+    files,
+    visibility,
+    paid,
+    hash: scan.hash,
+    workspaceSlug: ws?.slug || null
+  }, token);
+
+  logger.log(t('store.publish_skill_done', { slug, url: `${baseUrl}/store/skills/${slug}` }));
+  return { ok: true, slug, visibility, paid, fileCount, response };
+}
+
+// ── skill:install:store ─────────────────────────────────────────────────────
+
+async function runSkillInstallStore({ args, options, logger, t }) {
+  const config = await readConfig();
+  const token = requireToken(config, t);
+  const projectDir = await findProjectRoot(path.resolve(process.cwd(), args[0] || '.'));
+  const baseUrl = resolveBaseUrl(config);
+
+  const ref = String(options.slug || options.code || args[1] || args[0] || '').trim();
+  if (!ref) throw new Error(t('store.error_missing_code_or_slug'));
+
+  logger.log(t('store.install_skill_fetching', { ref }));
+  const response = await storePost(`${baseUrl}/api/store/skills/install`, { ref }, token);
+
+  const slug = response.slug;
+  if (!slug || !response.files || typeof response.files !== 'object') {
+    throw new Error(t('store.error_invalid_response'));
+  }
+
+  // Install-side preview and scan
+  const publisher = response.publisher || 'unknown';
+  const version = response.version || '?';
+  const serverHash = response.hash || null;
+  const trusted = Boolean(response.trusted);
+  const downloads = response.downloads != null ? response.downloads : null;
+  const rating = response.rating != null ? `${Number(response.rating).toFixed(1)}/5` : null;
+
+  logger.log(t('store.install_preview_header', { slug, publisher, version }));
+  if (trusted) logger.log(t('store.install_preview_trusted'));
+  else logger.log(t('store.install_preview_unverified'));
+  if (downloads != null) logger.log(t('store.install_preview_downloads', { count: downloads }));
+  if (rating) logger.log(t('store.install_preview_rating', { rating }));
+  if (serverHash) logger.log(t('store.install_preview_hash', { hash: serverHash.slice(0, 12) }));
+
+  // Scan files received from server before writing
+  const stringFiles = Object.fromEntries(
+    Object.entries(response.files).filter(([, v]) => typeof v === 'string')
+  );
+  const scan = scanPackage(stringFiles, 'skill');
+  formatScanReport(scan, logger);
+  if (!scan.ok) throw new Error(t('store.error_install_scan_failed', { slug }));
+
+  // Verify hash integrity if server sent one
+  if (serverHash && scan.hash !== serverHash) {
+    throw new Error(t('store.error_hash_mismatch', { slug }));
+  }
+
+  if (options.inspect) {
+    logger.log(t('store.install_inspect_files', { count: Object.keys(stringFiles).length }));
+    for (const f of Object.keys(stringFiles).sort()) logger.log(`  ${f}`);
+    logger.log(t('store.install_inspect_hint'));
+    return { ok: true, slug, inspect: true, files: Object.keys(stringFiles) };
+  }
+
+  if (!trusted && !options.force) {
+    logger.log(t('store.install_unverified_hint', { slug }));
+  }
+
+  const destDir = path.join(projectDir, '.aioson', 'installed-skills', slug);
+  await fs.mkdir(destDir, { recursive: true });
+
+  for (const [relPath, content] of Object.entries(stringFiles)) {
+    const filePath = path.join(destDir, relPath);
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, content, 'utf8');
+  }
+
+  logger.log(t('store.install_skill_done', { slug, path: destDir }));
+  return { ok: true, slug, path: destDir };
+}
+
+// ── skill:list --remote ──────────────────────────────────────────────────────
+
+async function runSkillListRemote({ args, options, logger, t }) {
+  const config = await readConfig();
+  const token = requireToken(config, t);
+  const baseUrl = resolveBaseUrl(config);
+  logger.log(t('store.list_remote_fetching', { type: 'skills' }));
+  const response = await storeGet(`${baseUrl}/api/store/skills`, token);
+  const skills = response.skills || [];
+  if (skills.length === 0) {
+    logger.log(t('store.list_remote_empty', { type: 'skills' }));
+  } else {
+    logger.log(t('store.list_remote_header', { count: skills.length, type: 'skills' }));
+    for (const s of skills) {
+      logger.log(t('store.list_remote_item', { slug: s.slug, name: s.title || s.slug, visibility: s.visibility || '?' }));
+    }
+  }
+  return { ok: true, skills, remote: true };
+}
+
+module.exports = { runSkillPublish, runSkillInstallStore, runSkillListRemote };