@a83/orbiter-admin 0.2.0

package/src/routes/github.js

@@ -0,0 +1,133 @@
+import { Hono } from 'hono';
+import { openPod } from '@a83/orbiter-core';
+import { readFileSync } from 'node:fs';
+
+export const githubRoutes = new Hono();
+
+const API = 'https://api.github.com';
+
+function ghHeaders(token) {
+  return {
+    Authorization: `Bearer ${token}`,
+    Accept:        'application/vnd.github+json',
+    'X-GitHub-Api-Version': '2022-11-28',
+    'Content-Type': 'application/json',
+    'User-Agent':   'orbiter-cms',
+  };
+}
+
+async function ghGet(token, path) {
+  const res = await fetch(`${API}${path}`, { headers: ghHeaders(token) });
+  if (!res.ok) throw new Error(`GitHub GET ${path}: ${res.status} ${await res.text()}`);
+  return res.json();
+}
+
+async function ghPost(token, path, body) {
+  const res = await fetch(`${API}${path}`, { method: 'POST', headers: ghHeaders(token), body: JSON.stringify(body) });
+  if (!res.ok) throw new Error(`GitHub POST ${path}: ${res.status} ${await res.text()}`);
+  return res.json();
+}
+
+async function ghPatch(token, path, body) {
+  const res = await fetch(`${API}${path}`, { method: 'PATCH', headers: ghHeaders(token), body: JSON.stringify(body) });
+  if (!res.ok) throw new Error(`GitHub PATCH ${path}: ${res.status} ${await res.text()}`);
+  return res.json();
+}
+
+const MIME_EXT = {
+  'image/jpeg': '.jpg', 'image/png': '.png', 'image/gif': '.gif',
+  'image/webp': '.webp', 'image/svg+xml': '.svg', 'image/avif': '.avif',
+  'application/pdf': '.pdf', 'video/mp4': '.mp4', 'video/webm': '.webm',
+};
+
+function extFor(mime, filename) {
+  if (MIME_EXT[mime]) return MIME_EXT[mime];
+  const m = filename.match(/\.[^.]+$/);
+  return m ? m[0] : '.bin';
+}
+
+// POST /api/github/push — commit pod + media to GitHub
+githubRoutes.post('/push', async (c) => {
+  const podPath = c.get('podPath');
+  const db      = openPod(podPath);
+  const token   = db.getMeta('github.token')  ?? '';
+  const repo    = db.getMeta('github.repo')   ?? '';
+  const branch  = db.getMeta('github.branch') ?? 'main';
+
+  if (!token || !repo) {
+    db.close();
+    return c.json({ ok: false, message: 'GitHub token and repo not configured in Settings.' }, 400);
+  }
+
+  try {
+    // Read media rows (with BLOBs)
+    const media = db.db.prepare('SELECT id, filename, mime_type, data FROM _media').all();
+
+    // Build media index (no BLOBs)
+    const mediaRows   = db.db.prepare('SELECT id, filename, mime_type, size, alt, folder, created_at FROM _media').all();
+    const indexEntries = mediaRows.map(r => ({
+      id:         r.id,
+      filename:   r.filename,
+      mime_type:  r.mime_type,
+      size:       r.size,
+      alt:        r.alt ?? '',
+      folder:     r.folder ?? '',
+      created_at: r.created_at,
+      file:       `media/${r.id}${extFor(r.mime_type, r.filename)}`,
+    }));
+    const indexJson = JSON.stringify({ version: 1, media: indexEntries }, null, 2);
+
+    // Mark storage mode so GH Action knows to unpack
+    db.setMeta('storage.mode', 'git');
+    db.close();
+
+    // Read pod as base64 (after writing storage.mode)
+    const podBase64 = readFileSync(podPath).toString('base64');
+
+    const files = [
+      { path: 'content.pod',      content: podBase64, encoding: 'base64' },
+      { path: 'media-index.json', content: Buffer.from(indexJson).toString('base64'), encoding: 'base64' },
+    ];
+
+    for (const row of media) {
+      if (!row.data || row.data.length === 0) continue;
+      const ext = extFor(row.mime_type, row.filename);
+      files.push({ path: `media/${row.id}${ext}`, content: row.data.toString('base64'), encoding: 'base64' });
+    }
+
+    // Commit via Git Trees API
+    const refData    = await ghGet(token, `/repos/${repo}/git/refs/heads/${branch}`);
+    const latestSha  = refData.object.sha;
+    const commitData = await ghGet(token, `/repos/${repo}/git/commits/${latestSha}`);
+    const treeSha    = commitData.tree.sha;
+
+    const treeItems = await Promise.all(
+      files.map(async f => {
+        const blob = await ghPost(token, `/repos/${repo}/git/blobs`, { content: f.content, encoding: f.encoding });
+        return { path: f.path, mode: '100644', type: 'blob', sha: blob.sha };
+      })
+    );
+
+    const newTree   = await ghPost(token, `/repos/${repo}/git/trees`, { base_tree: treeSha, tree: treeItems });
+    const newCommit = await ghPost(token, `/repos/${repo}/git/commits`, {
+      message: `orbiter: publish content [${new Date().toISOString().slice(0, 10)}]`,
+      tree:    newTree.sha,
+      parents: [latestSha],
+    });
+    await ghPatch(token, `/repos/${repo}/git/refs/heads/${branch}`, { sha: newCommit.sha, force: false });
+
+    return c.json({ ok: true, message: `Pushed ${files.length} files to ${repo}@${branch}`, commit: newCommit.sha });
+
+  } catch (err) {
+    return c.json({ ok: false, message: err.message ?? 'Unknown error' }, 500);
+  }
+});
+
+// GET /api/github/status
+githubRoutes.get('/status', (c) => {
+  const db     = openPod(c.get('podPath'));
+  const token  = db.getMeta('github.token') ?? '';
+  const repo   = db.getMeta('github.repo')  ?? '';
+  db.close();
+  return c.json({ configured: !!(token && repo) });
+});

package/src/routes/import.js

@@ -0,0 +1,120 @@
+import { Hono } from 'hono';
+import { openPod } from '@a83/orbiter-core';
+import { randomUUID } from 'node:crypto';
+import { parseWXR, buildImportPlan, executeImport } from '../wp-importer.js';
+
+export const importRoutes = new Hono();
+
+// In-memory token store — holds parsed WXR between analyze and execute (30 min TTL)
+const pendingImports = new Map();
+setInterval(() => {
+  const cutoff = Date.now() - 30 * 60 * 1000;
+  for (const [k, v] of pendingImports) {
+    if (v.ts < cutoff) pendingImports.delete(k);
+  }
+}, 5 * 60 * 1000);
+
+// POST /api/import/analyze — upload WXR XML, return plan + token
+importRoutes.post('/analyze', async (c) => {
+  const form = await c.req.formData();
+  const file = form.get('wxr_file');
+  if (!file || typeof file === 'string' || file.size === 0)
+    return c.json({ error: 'No file provided' }, 400);
+
+  try {
+    const xmlText = await file.text();
+    const parsed  = parseWXR(xmlText);
+    const plan    = buildImportPlan(parsed);
+    const token   = randomUUID();
+    pendingImports.set(token, { parsed, ts: Date.now() });
+    return c.json({ token, plan });
+  } catch (err) {
+    return c.json({ error: `Parse error: ${err.message}` }, 422);
+  }
+});
+
+// POST /api/import/execute — run WXR import using stored token
+importRoutes.post('/execute', async (c) => {
+  const body = await c.req.json().catch(() => ({}));
+  const { token, selectedTypes, downloadMedia, onDuplicate } = body;
+
+  if (!token || !pendingImports.has(token))
+    return c.json({ error: 'Import token expired or invalid. Please re-upload your file.' }, 400);
+
+  const { parsed } = pendingImports.get(token);
+  pendingImports.delete(token);
+
+  const db = openPod(c.get('podPath'));
+  try {
+    const results = await executeImport(db, parsed, {
+      selectedTypes: selectedTypes ?? [],
+      downloadMedia: !!downloadMedia,
+      onDuplicate:   onDuplicate ?? 'skip',
+    });
+    db.close();
+    return c.json(results);
+  } catch (err) {
+    db.close();
+    return c.json({ error: err.message }, 500);
+  }
+});
+
+// POST /api/import/markdown — import .md files with frontmatter
+importRoutes.post('/markdown', async (c) => {
+  const form      = await c.req.formData();
+  const targetCol = form.get('md_collection')?.toString() ?? '';
+  const onDup     = form.get('on_duplicate')?.toString() ?? 'skip';
+  const files     = form.getAll('md_files').filter(f => f instanceof File && f.size > 0);
+
+  if (files.length === 0) return c.json({ error: 'No files provided' }, 400);
+  if (!targetCol)         return c.json({ error: 'No target collection selected' }, 400);
+
+  const db  = openPod(c.get('podPath'));
+  const col = db.getCollection(targetCol);
+  if (!col) { db.close(); return c.json({ error: `Collection "${targetCol}" not found` }, 404); }
+
+  let imported = 0, skipped = 0;
+  const now = () => new Date().toISOString().replace('T', ' ').replace(/\.\d{3}Z$/, '');
+
+  function parseFrontmatter(text) {
+    const m = text.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
+    if (!m) return { data: {}, body: text.trim() };
+    const data = {};
+    for (const line of m[1].split('\n')) {
+      const kv = line.match(/^(\w[\w-]*):\s*(.+)$/);
+      if (!kv) continue;
+      let val = kv[2].trim();
+      if (val.startsWith('"') && val.endsWith('"')) val = val.slice(1, -1);
+      else if (val === 'true')  val = true;
+      else if (val === 'false') val = false;
+      else if (val !== '' && !isNaN(Number(val))) val = Number(val);
+      data[kv[1]] = val;
+    }
+    return { data, body: m[2].trim() };
+  }
+
+  for (const f of files) {
+    const text   = await f.text();
+    const parsed = parseFrontmatter(text);
+    const slug   = String(parsed.data.slug ?? f.name.replace(/\.md$/, '').toLowerCase().replace(/\s+/g, '-'));
+    delete parsed.data.slug;
+    const entryData = { ...parsed.data, body: parsed.data.body ?? parsed.body };
+    const status    = String(parsed.data.status ?? 'draft');
+    delete entryData.status;
+
+    const existing = db.db.prepare('SELECT id FROM _entries WHERE collection_id = ? AND slug = ?').get(targetCol, slug);
+    if (existing && onDup === 'skip') { skipped++; continue; }
+
+    if (existing) {
+      db.db.prepare('UPDATE _entries SET data=?,status=?,updated_at=? WHERE id=?')
+        .run(JSON.stringify(entryData), status, now(), existing.id);
+    } else {
+      db.db.prepare('INSERT INTO _entries (id,collection_id,slug,data,status) VALUES (?,?,?,?,?)')
+        .run(randomUUID(), targetCol, slug, JSON.stringify(entryData), status);
+    }
+    imported++;
+  }
+
+  db.close();
+  return c.json({ type: 'markdown', imported, skipped });
+});

package/src/routes/info.js

@@ -0,0 +1,19 @@
+import { Hono } from 'hono';
+import { openPod } from '@a83/orbiter-core';
+
+export const infoRoutes = new Hono();
+
+// GET /api/info — pod path, format version, collection stats
+infoRoutes.get('/', (c) => {
+  const podPath = c.get('podPath');
+  const db      = openPod(podPath);
+  const cols    = db.getCollections().map(col => ({
+    id:     col.id,
+    label:  col.label,
+    total:  db.getEntries(col.id).length,
+    parent: db.getMeta(`collection.${col.id}.parent`) ?? null,
+  }));
+  const version = db.getMeta('format_version') ?? '1';
+  db.close();
+  return c.json({ podPath, formatVersion: version, collections: cols });
+});

package/src/routes/media.js

@@ -0,0 +1,95 @@
+import { Hono } from 'hono';
+import { openPod } from '@a83/orbiter-core';
+import { randomUUID } from 'node:crypto';
+
+export const mediaRoutes = new Hono();
+
+// GET /api/media?folder=
+mediaRoutes.get('/', (c) => {
+  const folder = c.req.query('folder') ?? null;
+  const db     = openPod(c.get('podPath'));
+  const items  = db.listMedia(folder);
+  db.close();
+  return c.json(items);
+});
+
+// GET /api/media/:id/raw  — serve the binary
+mediaRoutes.get('/:id/raw', (c) => {
+  const db   = openPod(c.get('podPath'));
+  const item = db.getMediaItem(c.req.param('id'));
+  db.close();
+  if (!item) return c.json({ error: 'Not found' }, 404);
+  return new Response(item.data, {
+    headers: {
+      'Content-Type':  item.mime_type,
+      'Cache-Control': 'public, max-age=31536000, immutable',
+    },
+  });
+});
+
+// POST /api/media  — multipart upload
+mediaRoutes.post('/', async (c) => {
+  const form     = await c.req.formData();
+  const file     = form.get('file');
+  const alt      = form.get('alt')?.toString()    ?? null;
+  const folder   = form.get('folder')?.toString() ?? '';
+
+  if (!file || typeof file === 'string') return c.json({ error: 'No file provided' }, 400);
+
+  const buffer   = Buffer.from(await file.arrayBuffer());
+  const id       = randomUUID();
+  const db       = openPod(c.get('podPath'));
+  db.insertMedia(id, file.name, file.type, buffer.byteLength, buffer, alt, folder);
+  const item = db.getMediaItem(id);
+  db.close();
+
+  const { data: _, ...meta } = item;
+  return c.json(meta, 201);
+});
+
+// POST /api/media/import-url  — server-side fetch from a public URL (Dropbox, GDrive, etc.)
+mediaRoutes.post('/import-url', async (c) => {
+  let body;
+  try { body = await c.req.json(); } catch { return c.json({ error: 'Invalid JSON' }, 400); }
+  let { url, alt, folder } = body;
+  if (!url) return c.json({ error: 'No URL provided' }, 400);
+
+  // Dropbox: convert share link to direct download
+  if (/dropbox\.com/.test(url)) {
+    url = url.replace(/[?&]dl=0/, '').replace(/(\?.*)$/, '$1&dl=1');
+    if (!url.includes('?')) url += '?dl=1';
+  }
+  // Google Drive: convert /file/d/ID/view to direct download
+  const gdrive = url.match(/drive\.google\.com\/file\/d\/([^/]+)/);
+  if (gdrive) url = `https://drive.google.com/uc?export=download&id=${gdrive[1]}`;
+
+  let resp;
+  try {
+    resp = await fetch(url, { redirect: 'follow', headers: { 'User-Agent': 'Orbiter-Admin/1.0' } });
+  } catch (err) {
+    return c.json({ error: `Fetch failed: ${err.message}` }, 400);
+  }
+  if (!resp.ok) return c.json({ error: `Remote returned ${resp.status}` }, 400);
+
+  const mime     = (resp.headers.get('content-type') || 'application/octet-stream').split(';')[0].trim();
+  const buffer   = Buffer.from(await resp.arrayBuffer());
+  const filename = url.split('/').pop()?.split('?')[0] || 'imported';
+  const id       = randomUUID();
+  const db       = openPod(c.get('podPath'));
+  db.insertMedia(id, filename, mime, buffer.byteLength, buffer, alt ?? null, folder ?? '');
+  const item = db.getMediaItem(id);
+  db.close();
+
+  const { data: _, ...meta } = item;
+  return c.json(meta, 201);
+});
+
+// DELETE /api/media/:id
+mediaRoutes.delete('/:id', (c) => {
+  const db   = openPod(c.get('podPath'));
+  const item = db.getMediaItem(c.req.param('id'));
+  if (!item) { db.close(); return c.json({ error: 'Not found' }, 404); }
+  db.deleteMedia(item.id);
+  db.close();
+  return c.json({ ok: true });
+});

package/src/routes/meta.js

@@ -0,0 +1,54 @@
+import { Hono } from 'hono';
+import { openPod } from '@a83/orbiter-core';
+
+export const metaRoutes = new Hono();
+
+const ALLOWED_KEYS = [
+  'site.name', 'site.url', 'site.description', 'site.locale', 'site.locales',
+  'build.webhook_url',
+  'github.token', 'github.repo', 'github.branch',
+  'api.enabled', 'api.token',
+  'dashboard.notes', 'dashboard.todos',
+  'ui.theme',
+  'format_version',
+];
+
+// GET /api/meta — returns all allowed keys as a flat object
+metaRoutes.get('/', (c) => {
+  const db  = openPod(c.get('podPath'));
+  const out = {};
+  for (const key of ALLOWED_KEYS) out[key] = db.getMeta(key) ?? null;
+  db.close();
+  return c.json(out);
+});
+
+// GET /api/meta/:key
+metaRoutes.get('/:key', (c) => {
+  const key = c.req.param('key').replace(/~/g, '.');
+  const db  = openPod(c.get('podPath'));
+  const val = db.getMeta(key);
+  db.close();
+  return c.json({ key, value: val });
+});
+
+// PUT /api/meta — batch update
+metaRoutes.put('/', async (c) => {
+  const body = await c.req.json();
+  const db   = openPod(c.get('podPath'));
+  for (const [key, value] of Object.entries(body)) {
+    if (ALLOWED_KEYS.includes(key)) db.setMeta(key, value == null ? '' : String(value));
+  }
+  db.close();
+  return c.json({ ok: true });
+});
+
+// PUT /api/meta/:key — single key update
+metaRoutes.put('/:key', async (c) => {
+  const key = c.req.param('key').replace(/~/g, '.');
+  if (!ALLOWED_KEYS.includes(key)) return c.json({ error: 'Key not allowed' }, 403);
+  const { value } = await c.req.json();
+  const db = openPod(c.get('podPath'));
+  db.setMeta(key, value == null ? '' : String(value));
+  db.close();
+  return c.json({ ok: true });
+});

package/src/routes/search.js

@@ -0,0 +1,62 @@
+import { Hono } from 'hono';
+import { openPod } from '@a83/orbiter-core';
+
+export const searchRoutes = new Hono();
+
+// GET /api/search/recent — last N entries across all collections
+searchRoutes.get('/recent', (c) => {
+  const limit = Math.min(parseInt(c.req.query('limit') ?? '10', 10), 50);
+  const db    = openPod(c.get('podPath'));
+  const cols  = db.getCollections();
+  const colMap = Object.fromEntries(cols.map(c => [c.id, c.label]));
+
+  const rows = db.db
+    .prepare(`SELECT e.*, e.collection_id as collection FROM _entries e ORDER BY e.updated_at DESC LIMIT ?`)
+    .all(limit);
+
+  const results = rows.map(r => {
+    const data = JSON.parse(r.data);
+    return {
+      collection: r.collection_id,
+      label:      colMap[r.collection_id] ?? r.collection_id,
+      slug:       r.slug,
+      title:      data.title ?? r.slug,
+      status:     r.status,
+      updated_at: r.updated_at,
+    };
+  });
+  db.close();
+  return c.json(results);
+});
+
+// GET /api/search?q=
+searchRoutes.get('/', (c) => {
+  const q = (c.req.query('q') ?? '').trim().toLowerCase();
+  if (!q) return c.json([]);
+
+  const db          = openPod(c.get('podPath'));
+  const collections = db.getCollections();
+  const results     = [];
+
+  for (const col of collections) {
+    const entries = db.getEntries(col.id);
+    for (const entry of entries) {
+      const title = (entry.data?.title ?? entry.slug ?? '').toLowerCase();
+      const body  = (entry.data?.body  ?? '').toLowerCase();
+      if (title.includes(q) || body.includes(q) || entry.slug.includes(q)) {
+        results.push({
+          type:       'entry',
+          collection: col.id,
+          label:      col.label,
+          slug:       entry.slug,
+          title:      entry.data?.title ?? entry.slug,
+          status:     entry.status,
+        });
+        if (results.length >= 20) break;
+      }
+    }
+    if (results.length >= 20) break;
+  }
+  db.close();
+  return c.json(results);
+});

package/src/routes/users.js

@@ -0,0 +1,46 @@
+import { Hono } from 'hono';
+import { openPod, hashPassword } from '@a83/orbiter-core';
+import { randomUUID } from 'node:crypto';
+import { requireAdmin } from '../middleware/auth.js';
+
+export const userRoutes = new Hono();
+
+// All user management requires admin role
+userRoutes.use('*', requireAdmin);
+
+// GET /api/users
+userRoutes.get('/', (c) => {
+  const db    = openPod(c.get('podPath'));
+  const users = db.getUsers();
+  db.close();
+  return c.json(users);
+});
+
+// POST /api/users
+userRoutes.post('/', async (c) => {
+  const { username, password, role = 'editor' } = await c.req.json();
+  if (!username || !password) return c.json({ error: 'username and password are required' }, 400);
+  if (!['admin', 'editor'].includes(role)) return c.json({ error: 'Invalid role' }, 400);
+
+  const db       = openPod(c.get('podPath'));
+  const existing = db.getUserByUsername(username);
+  if (existing) { db.close(); return c.json({ error: `User "${username}" already exists` }, 409); }
+
+  const hashed = await hashPassword(password);
+  const id     = randomUUID();
+  db.insertUser(id, username, hashed, role);
+  db.close();
+  return c.json({ ok: true, id, username, role }, 201);
+});
+
+// DELETE /api/users/:id
+userRoutes.delete('/:id', (c) => {
+  const currentUser = c.get('user');
+  if (currentUser.id === c.req.param('id')) {
+    return c.json({ error: 'Cannot delete your own account' }, 400);
+  }
+  const db = openPod(c.get('podPath'));
+  db.deleteUser(c.req.param('id'));
+  db.close();
+  return c.json({ ok: true });
+});

package/src/server.js

@@ -0,0 +1,85 @@
+import { Hono } from 'hono';
+import { cors } from 'hono/cors';
+import { serveStatic } from '@hono/node-server/serve-static';
+import { serve } from '@hono/node-server';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+// Ensure CWD is the package root so serveStatic finds ./public
+const __dirname = dirname(fileURLToPath(import.meta.url));
+process.chdir(join(__dirname, '..'));
+import { authRoutes }       from './routes/auth.js';
+import { collectionRoutes } from './routes/collections.js';
+import { entryRoutes }      from './routes/entries.js';
+import { mediaRoutes }      from './routes/media.js';
+import { userRoutes }       from './routes/users.js';
+import { metaRoutes }       from './routes/meta.js';
+import { accountRoutes }    from './routes/account.js';
+import { buildRoutes }      from './routes/build.js';
+import { searchRoutes }     from './routes/search.js';
+import { githubRoutes }     from './routes/github.js';
+import { infoRoutes }       from './routes/info.js';
+import { importRoutes }     from './routes/import.js';
+import { requireAuth }      from './middleware/auth.js';
+
+const POD_PATH = process.env.ORBITER_POD;
+if (!POD_PATH) {
+  console.error('Error: ORBITER_POD environment variable is required.');
+  console.error('Example: ORBITER_POD=/path/to/content.pod npm start');
+  process.exit(1);
+}
+
+const PORT        = parseInt(process.env.PORT ?? '4322', 10);
+const ALLOWED_ORIGINS = process.env.ADMIN_ORIGIN
+  ? process.env.ADMIN_ORIGIN.split(',').map(s => s.trim())
+  : ['http://localhost:4321', 'http://localhost:4322'];
+
+export function createApp(podPath) {
+  const app = new Hono();
+
+  // Inject pod path into every request context
+  app.use('*', async (c, next) => {
+    c.set('podPath', podPath);
+    await next();
+  });
+
+  app.use('*', cors({
+    origin:      ALLOWED_ORIGINS,
+    credentials: true,
+  }));
+
+  // Public routes
+  app.route('/api/auth', authRoutes);
+
+  // Protected routes
+  const api = new Hono();
+  api.use('*', requireAuth);
+  api.route('/collections',  collectionRoutes);
+  api.route('/collections',  entryRoutes);
+  api.route('/media',        mediaRoutes);
+  api.route('/users',        userRoutes);
+  api.route('/meta',         metaRoutes);
+  api.route('/account',      accountRoutes);
+  api.route('/build',        buildRoutes);
+  api.route('/search',       searchRoutes);
+  api.route('/github',       githubRoutes);
+  api.route('/info',         infoRoutes);
+  api.route('/import',       importRoutes);
+
+  app.route('/api', api);
+
+  app.get('/health', (c) => c.json({ ok: true, pod: podPath }));
+
+  // Redirect root to login
+  app.get('/', (c) => c.redirect('/login.html'));
+
+  // Serve static frontend files from public/
+  app.use('/*', serveStatic({ root: './public' }));
+
+  return app;
+}
+
+serve({ fetch: createApp(POD_PATH).fetch, port: PORT }, () => {
+  console.log(`Orbiter Admin API  →  http://localhost:${PORT}`);
+  console.log(`Pod: ${POD_PATH}`);
+});