@prismer/runtime 2.0.8 → 2.2.55

package/built-in-skills/skill-builder/scripts/ingest.mjs

@@ -0,0 +1,265 @@
+#!/usr/bin/env node
+// skill-builder ingest — material→bundle→live catalog, via SDK + API key.
+//
+// Zero runtime dependencies (Node ≥18 built-ins only). Reads a SS-01 skill
+// bundle directory, parses SKILL.md frontmatter, builds an SS-01 contentManifest
+// with a server-matching merkle revision, and POSTs it to the real catalog
+// endpoint authenticated with an `sk-prismer-*` API key.
+//
+// Usage:
+//   PRISMER_API_KEY=sk-prismer-... [PRISMER_CLOUD_BASE=http://127.0.0.1:3000] \
+//     node scripts/ingest.mjs <bundle-dir> [--install] [--agent <imUserId>] [--json]
+//
+// Env:
+//   PRISMER_API_KEY   (required) Bearer token; admin not required for skill create.
+//   PRISMER_CLOUD_BASE (default http://127.0.0.1:3000) cloud base URL.
+
+import { createHash } from 'node:crypto';
+import { readFileSync, readdirSync, statSync } from 'node:fs';
+import { join, relative, sep } from 'node:path';
+
+function die(msg, code = 1) {
+  console.error(`[skill-builder] ✗ ${msg}`);
+  process.exit(code);
+}
+
+const args = process.argv.slice(2);
+const secretOptions = new Set(['--api-key', '--token', '--jwt', '--secret', '--password']);
+let bundleDir;
+let wantInstall = false;
+let asJson = false;
+let agentId;
+for (let index = 0; index < args.length; index += 1) {
+  const arg = args[index];
+  const equalsAt = arg.indexOf('=');
+  const option = equalsAt === -1 ? arg : arg.slice(0, equalsAt);
+  if (secretOptions.has(option)) {
+    die(`${option} is forbidden; credentials must come from environment variables`, 2);
+  }
+  if (arg === '--install') {
+    wantInstall = true;
+    continue;
+  }
+  if (arg === '--json') {
+    asJson = true;
+    continue;
+  }
+  if (arg === '--agent') {
+    const value = args[index + 1];
+    if (!value || value.startsWith('--')) die('--agent requires an imUserId', 2);
+    agentId = value;
+    index += 1;
+    continue;
+  }
+  if (arg.startsWith('--')) die(`unknown argument at position ${index + 1}`, 2);
+  if (bundleDir) die('only one bundle directory may be supplied', 2);
+  bundleDir = arg;
+}
+
+const API_KEY = process.env.PRISMER_API_KEY;
+const BASE = (process.env.PRISMER_CLOUD_BASE || 'http://127.0.0.1:3000').replace(/\/$/, '');
+
+if (!bundleDir) die('usage: node ingest.mjs <bundle-dir> [--install] [--agent <imUserId>] [--json]');
+if (!API_KEY) die('PRISMER_API_KEY env is required (sk-prismer-*)');
+let target;
+try {
+  target = new URL(BASE);
+} catch {
+  die('PRISMER_CLOUD_BASE must be a valid URL', 2);
+}
+if (
+  !['http:', 'https:'].includes(target.protocol) ||
+  target.username ||
+  target.password ||
+  target.search ||
+  target.hash
+) {
+  die('PRISMER_CLOUD_BASE must be a plain http(s) origin without credentials, query, or hash', 2);
+}
+const isLocalTarget = ['localhost', '127.0.0.1', '::1', 'host.docker.internal'].includes(target.hostname);
+const allowRemote = ['1', 'true', 'yes'].includes(String(process.env.PRISMER_ALLOW_REMOTE_WRITE).toLowerCase());
+if (!isLocalTarget && !allowRemote) {
+  die('remote mutation is blocked; set PRISMER_ALLOW_REMOTE_WRITE=1 after confirming the target environment', 2);
+}
+
+// ── collect bundle files (SS-01 §3.1 — exclude dotfiles + LICENSE*) ──────────
+const EXCLUDED = new Set(['.DS_Store', 'Thumbs.db', 'LICENSE', 'LICENSE.txt', 'LICENSE.md']);
+function collect(dir) {
+  const out = [];
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    if (entry.name.startsWith('.')) continue;
+    const abs = join(dir, entry.name);
+    if (entry.isDirectory()) out.push(...collect(abs));
+    else if (!EXCLUDED.has(entry.name)) out.push(abs);
+  }
+  return out;
+}
+
+let bundleStat;
+try {
+  bundleStat = statSync(bundleDir);
+} catch {
+  die(`bundle dir not found: ${bundleDir}`);
+}
+if (!bundleStat.isDirectory()) die(`not a directory: ${bundleDir}`);
+
+const absFiles = collect(bundleDir).sort();
+const toPosix = (abs) => relative(bundleDir, abs).split(sep).join('/');
+const files = absFiles.map((abs) => ({ path: toPosix(abs), bytes: readFileSync(abs) }));
+
+const skillMd = files.find((f) => f.path === 'SKILL.md');
+if (!skillMd) die('SKILL.md not found at bundle root');
+
+// ── parse frontmatter (minimal YAML — flat keys, lists, block scalars) ────
+function parseFrontmatter(text) {
+  const m = text.match(/^---\n([\s\S]*?)\n---\n?/);
+  if (!m) return { fm: {}, body: text };
+  const fm = {};
+  let key = null;
+  const lines = m[1].split('\n');
+  for (let index = 0; index < lines.length; index += 1) {
+    const rawLine = lines[index];
+    const line = rawLine.replace(/\s+$/, '');
+    if (!line.trim()) continue;
+    const listItem = line.match(/^\s+-\s+(.*)$/);
+    if (listItem && key) {
+      (Array.isArray(fm[key]) ? fm[key] : (fm[key] = [])).push(stripQuotes(listItem[1]));
+      continue;
+    }
+    const kv = line.match(/^([A-Za-z0-9_-]+):\s*(.*)$/);
+    if (kv) {
+      key = kv[1];
+      const val = kv[2];
+      const block = /^([|>])([+-])?$/.exec(val.trim());
+      if (block) {
+        const body = [];
+        let next = index + 1;
+        for (; next < lines.length; next += 1) {
+          const candidate = lines[next];
+          if (candidate.trim() && !/^\s+/.test(candidate)) break;
+          body.push(candidate);
+        }
+        const indents = body
+          .filter((candidate) => candidate.trim())
+          .map((candidate) => /^\s*/.exec(candidate)?.[0].length ?? 0);
+        const indent = indents.length > 0 ? Math.min(...indents) : 0;
+        const unindented = body.map((candidate) => candidate.slice(Math.min(indent, candidate.length)));
+        let parsed =
+          block[1] === '>'
+            ? unindented.reduce((out, candidate, bodyIndex) => {
+                if (bodyIndex === 0) return candidate;
+                const previous = unindented[bodyIndex - 1] ?? '';
+                return out + (previous === '' || candidate === '' ? '\n' : ' ') + candidate;
+              }, '')
+            : unindented.join('\n');
+        if (block[2] === '-') parsed = parsed.replace(/\n+$/, '');
+        else if (block[2] !== '+') parsed = parsed.replace(/\n*$/, '\n');
+        fm[key] = parsed;
+        index = next - 1;
+      } else if (val === '')
+        fm[key] = []; // expect a list or nested block below
+      else fm[key] = stripQuotes(val);
+    }
+  }
+  return { fm, body: text.slice(m[0].length) };
+}
+const stripQuotes = (s) => s.replace(/^["']|["']$/g, '').trim();
+
+const { fm } = parseFrontmatter(skillMd.bytes.toString('utf8'));
+const name = fm.name;
+if (!name || !/^[a-z][a-z0-9-]*$/.test(name)) die(`frontmatter.name invalid or missing: ${name}`);
+if (!fm.description || fm.description === '|' || fm.description === '>') {
+  die('frontmatter.description is required');
+}
+
+// category: prefer metadata.category; the nested `metadata:` block isn't parsed
+// by the flat reader, so allow a top-level `category:` too, else default.
+const category = fm.category || 'general';
+const compatibility = Array.isArray(fm.compatibility)
+  ? fm.compatibility
+  : fm.compatibility
+    ? [fm.compatibility]
+    : undefined;
+
+// ── build SS-01 manifest (merkle matches src/im/skills/manifest.ts) ──────────
+const sha256 = (buf) => createHash('sha256').update(buf).digest('hex');
+const manifest = files.map((f) => ({
+  path: f.path,
+  size: f.bytes.byteLength,
+  sha256: sha256(f.bytes),
+  inline: true,
+  content: f.bytes.toString('base64'),
+}));
+const revision = sha256(
+  [...manifest]
+    .sort((a, b) => a.path.localeCompare(b.path))
+    .map((f) => `${f.path}:${f.sha256}`)
+    .join('\n'),
+);
+
+const isMultiFile = files.length > 1;
+const createBody = {
+  name,
+  description: fm.description,
+  category,
+  ...(fm.license ? { license: fm.license } : {}),
+  ...(compatibility ? { compatibility } : {}),
+  // Single-file → send plain content (server wraps). Multi-file → send manifest.
+  content: skillMd.bytes.toString('utf8'),
+  ...(isMultiFile ? { contentManifest: manifest, contentManifestRevision: revision } : {}),
+};
+
+async function api(method, path, body) {
+  const res = await fetch(`${BASE}${path}`, {
+    method,
+    headers: { 'content-type': 'application/json', authorization: `Bearer ${API_KEY}` },
+    ...(body ? { body: JSON.stringify(body) } : {}),
+  });
+  let json = null;
+  try {
+    json = await res.json();
+  } catch {
+    /* non-JSON */
+  }
+  return { status: res.status, json };
+}
+
+(async () => {
+  const created = await api('POST', '/api/im/skills', createBody);
+  if (created.status === 409) die(`slug "${name}" already exists (409). Use update or pick a new name.`, 2);
+  if (created.status !== 201 || !created.json?.ok) {
+    die(`create failed (HTTP ${created.status}): ${created.json?.error || 'unknown error'}`);
+  }
+  const skill = created.json.data;
+  const result = {
+    id: skill.id,
+    slug: skill.slug,
+    rev: revision,
+    files: files.length,
+    installed: false,
+  };
+
+  if (wantInstall) {
+    const path = agentId
+      ? `/api/im/agents/${encodeURIComponent(agentId)}/skills`
+      : `/api/im/skills/${encodeURIComponent(skill.slug)}/install`;
+    const body = agentId ? { skillId: skill.slug } : {};
+    const inst = await api('POST', path, body);
+    if (inst.status >= 200 && inst.status < 300 && inst.json?.ok !== false) {
+      result.installed = agentId || true;
+    } else {
+      result.installError = `HTTP ${inst.status}: ${inst.json?.error || 'install failed'}`;
+    }
+  }
+
+  if (asJson) {
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    console.log(`[skill-builder] ✓ ingested ${result.slug}`);
+    console.log(`  id:        ${result.id}`);
+    console.log(`  rev:       ${result.rev}`);
+    console.log(`  files:     ${result.files}`);
+    console.log(`  installed: ${result.installed}${result.installError ? ` (${result.installError})` : ''}`);
+    console.log(`  verify:    cloud skill show ${result.slug} --content`);
+  }
+})().catch((err) => die(err?.message || String(err)));