elanous 0.2.0 → 0.2.4

package/src/loops/registry.ts

@@ -0,0 +1,174 @@
+import { readdirSync, readFileSync, statSync } from 'node:fs';
+import { isAbsolute, join, relative, resolve } from 'node:path';
+import { parse as parseYaml } from 'yaml';
+import type { Database } from 'bun:sqlite';
+import { debug } from '../debug/log.js';
+import { emitDecision } from '../live/detail-switch.js';
+import { cronMatches } from '../domains/cron-match.js';
+import { resolveTimeZone } from '../time/format.js';
+import { inventoryCrontab, listSchedules, openSchedulesDb, type ScheduleRow } from '../domains/schedule-registry.js';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
+import { runGraph, type GraphRunState } from '../graph-runner/runner.js';
+
+export interface LoopRun {
+  at: string;
+  status: GraphRunState['status'];
+  path: string;
+  runId: string;
+  failedNodes: string[];
+  durationMs: number | null;
+}
+export interface LoopEntry {
+  id: string;
+  title: string;
+  description: string | null;
+  file: string;
+  trigger: { cron: string | null; events: string[] };
+  jobs: Array<{ id: string; cron: string | null; enabled: boolean }>;
+  enabled: boolean;
+  lastRun: LoopRun | null;
+  nextRun: string | null;
+}
+export interface LoopRegistryOptions {
+  root?: string;
+  stateRoot?: string;
+  now?: Date;
+  /** An already-inventoried registry; keeps focused tests isolated. */
+  schedules?: ScheduleRow[];
+  scheduleAction?: (action: 'create' | 'enable' | 'disable', args: Record<string, unknown>) => Promise<unknown>;
+}
+
+function graphFiles(dir: string): string[] {
+  let entries;
+  try { entries = readdirSync(dir, { withFileTypes: true }); }
+  catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return [];
+    throw error;
+  }
+  return entries.flatMap(e => e.isDirectory() ? graphFiles(join(dir, e.name)) : e.isFile() && /\.ya?ml$/.test(e.name) ? [join(dir, e.name)] : []).sort();
+}
+
+/** Match only the actual graph CLI invocation, not a filename mentioned in a shell argument. */
+export function graphJobMatches(command: string | null, file: string, root: string): boolean {
+  if (!command) return false;
+  const invocation = /(?:^|&&\s*|;\s*)(?:(?:\S*\/)?(?:bun|node)\s+(?:\S*\/)?bin\/elanous\.mjs|(?:\S*\/)?elanous)\s+(?:--test(?:=\S+|\s+\S+)\s+)?graph\s+run\s+(['"]?)([^\s'";&|]+)\1(?=\s|$|[;&|])/g;
+  for (const match of command.matchAll(invocation)) {
+    const arg = match[2]!;
+    if (resolve(root, arg) === file || (isAbsolute(arg) && resolve(arg) === file)) return true;
+  }
+  return false;
+}
+
+function recentRuns(id: string, stateRoot: string, count = 5): LoopRun[] {
+  const dir = join(stateRoot, 'graph-runs', id);
+  let files: string[];
+  try { files = readdirSync(dir).filter(f => f.endsWith('.json') && !f.endsWith('.decision.json')); }
+  catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return [];
+    throw error;
+  }
+  return files.map(file => ({ file, at: statSync(join(dir, file)).mtimeMs }))
+    .sort((a, b) => b.at - a.at).slice(0, count).map(({ file, at }) => {
+      const path = join(dir, file);
+      const state = JSON.parse(readFileSync(path, 'utf8')) as GraphRunState;
+      if (state.graphId !== id) throw new Error(`graph run identity mismatch: ${path}`);
+      const start = state.startedAt ? Date.parse(state.startedAt) : NaN;
+      const end = state.finishedAt ? Date.parse(state.finishedAt) : NaN;
+      return { at: state.startedAt ?? new Date(at).toISOString(), status: state.status, path, runId: state.runId,
+        failedNodes: state.nodes.filter(n => !n.ok || !!n.error).map(n => n.nodeId),
+        durationMs: Number.isFinite(start) && Number.isFinite(end) ? Math.max(0, end - start) : null };
+    });
+}
+
+export function nextLoopFire(cron: string, now: Date): string | null {
+  if (cron.trim().split(/\s+/).length !== 5) return null;
+  let minute = Math.floor(now.getTime() / 60000) * 60000 + 60000;
+  const timeZone = resolveTimeZone().timeZone;
+  // Covers leap years and annual cron expressions; a nonmatching expression stays unknown.
+  for (let i = 0; i < 527040; i++, minute += 60000) {
+    if (cronMatches(cron, new Date(minute), { timeZone })) return new Date(minute).toISOString();
+  }
+  return null;
+}
+
+function schedules(opts: LoopRegistryOptions): ScheduleRow[] {
+  if (opts.schedules) return opts.schedules;
+  const db: Database = openSchedulesDb();
+  try {
+    inventoryCrontab(db);
+    return listSchedules(db);
+  } finally { db.close(); }
+}
+
+export function listLoops(opts: LoopRegistryOptions = {}): LoopEntry[] {
+  const root = resolve(opts.root ?? process.cwd());
+  const stateRoot = opts.stateRoot ?? effectiveInstanceRoot();
+  const rows = schedules(opts);
+  const loops: LoopEntry[] = [];
+  for (const file of graphFiles(join(root, 'graphs'))) {
+    let doc: Record<string, unknown> | null;
+    try { doc = parseYaml(readFileSync(file, 'utf8')) as Record<string, unknown> | null; }
+    catch (error) {
+      debug.log('loops.registry', 'graph-read-failed', { file, error: String(error) });
+      continue;
+    }
+    if (!doc || typeof doc !== 'object' || Array.isArray(doc) || typeof doc.graph_id !== 'string' || !doc.graph_id) continue;
+    const header = doc.loop && typeof doc.loop === 'object' && !Array.isArray(doc.loop) ? doc.loop as Record<string, unknown> : null;
+    const trigger = header?.trigger && typeof header.trigger === 'object' && !Array.isArray(header.trigger) ? header.trigger as Record<string, unknown> : null;
+    const declaredCron = typeof trigger?.cron === 'string' ? trigger.cron : null;
+    const events = Array.isArray(trigger?.events) ? trigger.events.filter((e): e is string => typeof e === 'string') : [];
+    const matched = rows.filter(row => graphJobMatches(row.command, file, root) && row.source === 'crontab' && row.run_via === 'crontab' && row.disabled_reason !== 'vanished');
+    if (!declaredCron && !events.length && !matched.length) continue;
+    if (!/^[a-zA-Z0-9][\w.-]*$/.test(doc.graph_id)) throw new Error(`unsafe loop graph_id: ${doc.graph_id}`);
+    if (loops.some(loop => loop.id === doc.graph_id)) throw new Error(`duplicate loop graph_id: ${doc.graph_id}`);
+    const jobs = matched.map(row => ({ id: row.id, cron: row.cron, enabled: !!row.enabled }));
+    const active = matched.filter(row => !!row.enabled && !!row.cron);
+    const next = active.map(row => nextLoopFire(row.cron!, opts.now ?? new Date())).filter((v): v is string => v !== null).sort()[0] ?? null;
+    const entry: LoopEntry = { id: doc.graph_id, title: typeof header?.title === 'string' ? header.title : doc.graph_id,
+      description: typeof header?.description === 'string' ? header.description : null, file: relative(root, file),
+      trigger: { cron: declaredCron, events }, jobs, enabled: matched.some(row => !!row.enabled),
+      lastRun: recentRuns(doc.graph_id, stateRoot, 1)[0] ?? null, nextRun: next };
+    loops.push(entry);
+  }
+  debug.log('loops.registry', 'list', { count: loops.length });
+  return loops;
+}
+
+export function loopStatus(id: string, opts: LoopRegistryOptions = {}): LoopEntry & { recentRuns: LoopRun[] } {
+  const loop = listLoops(opts).find(entry => entry.id === id);
+  if (!loop) throw new Error(`loop not found: ${id}`);
+  const recent = recentRuns(id, opts.stateRoot ?? effectiveInstanceRoot());
+  debug.log('loops.registry', 'status', { id, runs: recent.length });
+  return { ...loop, recentRuns: recent };
+}
+
+export async function setLoopEnabled(id: string, enabled: boolean, yes = false, opts: LoopRegistryOptions = {}): Promise<unknown> {
+  const loop = loopStatus(id, opts);
+  const action = enabled ? 'start' : 'stop';
+  if (!loop.jobs.length && (!enabled || !loop.trigger.cron)) throw new Error(`loop ${id} has no cron job to ${action}`);
+  const pending = loop.jobs.filter(job => job.enabled !== enabled);
+  if (!pending.length && loop.jobs.length) return { action, id, changed: false, enabled: loop.enabled };
+  const changes = loop.jobs.length ? pending.map(job => ({ action: enabled ? 'enable' : 'disable', id: job.id })) :
+    [{ action: 'create', cron: loop.trigger.cron, command: `elanous graph run ${loop.file}` }];
+  if (!yes) return { action, id, dryRun: true, changes, note: 'Apply with --yes (crontab backup).' };
+  const dispatch = opts.scheduleAction ?? (async (kind: 'create' | 'enable' | 'disable', args: Record<string, unknown>) => {
+    const { dispatchScheduleManage } = await import('../domains/schedule-manage-tool.js');
+    return dispatchScheduleManage({ action: kind, ...args });
+  });
+  const results = [];
+  for (const change of changes) {
+    const { action: kind, ...args } = change;
+    const result = await dispatch(kind as 'create' | 'enable' | 'disable', args);
+    if (result && typeof result === 'object' && 'error' in result) throw new Error(String(result.error));
+    results.push(result);
+  }
+  debug.log('loops.registry', action, { id, changes });
+  emitDecision({ kind: 'ROUTE', what: `루프 ${enabled ? '켬' : '끔'}: ${id}`, reason: enabled ? '사용자 요청으로 예약 발화 활성화' : '사용자 요청으로 예약 발화 일시 중지', purpose: '루프 라이프사이클 제어', target: id });
+  return { action, id, changed: true, results };
+}
+
+export async function runLoop(id: string, dryRun = false, opts: LoopRegistryOptions = {}): Promise<GraphRunState> {
+  const loop = loopStatus(id, opts);
+  debug.log('loops.registry', 'run', { id, dryRun });
+  return runGraph(join(resolve(opts.root ?? process.cwd()), loop.file), { dryRun, deps: { root: opts.stateRoot ?? effectiveInstanceRoot() } });
+}

package/src/market/official-keys.ts

@@ -0,0 +1,5 @@
+/** Public keys that sign the official Elanous marketplace index (signed-index SPEC §3). The private key stays offline
+ *  on the owner's machine. Clients trust these by default; `market.trustedKeys` in config may add keys (rotation overlap). */
+export const OFFICIAL_INDEX_KEYS: ReadonlyArray<{ keyId: string; publicKey: string }> = [
+  { keyId: '4d809b69', publicKey: 'iNHq4yuuJNuB6BSDyAZhcYvaGTImtOGfbIPGUg4EbNQ=' },
+];

package/src/market/publish.ts

@@ -0,0 +1,273 @@
+import { createHash, createPublicKey } from 'node:crypto';
+import { existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmSync, writeFileSync } from 'node:fs';
+import { basename, isAbsolute, join, posix, relative, resolve } from 'node:path';
+import { gunzipSync } from 'node:zlib';
+import { parse as parseYaml } from 'yaml';
+import { debug } from '../debug/log.js';
+import { packDirDeterministic } from './tgz.js';
+import { signIndex, verifyIndex, type MarketplaceIndex } from './signed-index.js';
+
+function unpackLocal(archive: Uint8Array, destination: string): void {
+  const tar = gunzipSync(archive);
+  const field = (part: Buffer) => part.toString('utf8').replace(/\0.*$/, '');
+  for (let offset = 0; offset + 512 <= tar.length;) {
+    const header = tar.subarray(offset, offset + 512);
+    if (header.every(byte => byte === 0)) break;
+    const size = parseInt(field(header.subarray(124, 136)).trim(), 8);
+    const name = field(header.subarray(0, 100));
+    const prefix = field(header.subarray(345, 500));
+    const path = prefix ? `${prefix}/${name}` : name;
+    if (!Number.isSafeInteger(size) || size < 0 || !path || path.split('/').some(part => !part || part === '.' || part === '..') ||
+        header[156] !== 48 || offset + 512 + size > tar.length) throw new Error('invalid packed archive');
+    const file = join(destination, path);
+    mkdirSync(join(file, '..'), { recursive: true });
+    writeFileSync(file, tar.subarray(offset + 512, offset + 512 + size),
+      { mode: parseInt(field(header.subarray(100, 108)).trim(), 8) });
+    offset += 512 + Math.ceil(size / 512) * 512;
+  }
+}
+
+export interface PublishResult {
+  ok: boolean;
+  sequence: number;
+  published: Array<{ name: string; version: string; sha256: string; bundled: string[] }>;
+  skipped: Array<{ dir: string; reason: string }>;
+  /** Published anyway, but a reviewer should look (e.g. a third-party graph relying on core recipes). */
+  warnings: Array<{ dir: string; graph: string; reason: 'third-party-core-recipe'; recipes: string[] }>;
+}
+
+export function publishMarket(input: {
+  pluginsDir: string;
+  bundleRoot?: string;
+  outDir: string;
+  market: { name: string; displayName: string };
+  key: { keyId: string; privateKeyPem: string };
+  source?: { repoUrl: string; sha: string; basePath: string };
+  now?: Date;
+}): PublishResult {
+  let sequence = 1;
+  let currentName: string | undefined;
+  let currentVersion: string | undefined;
+  try {
+    const indexPath = join(input.outDir, 'marketplace.json');
+    const previous: MarketplaceIndex | undefined = existsSync(indexPath) ? JSON.parse(readFileSync(indexPath, 'utf8')) : undefined;
+    if (previous) {
+      if (!Number.isSafeInteger(previous.sequence) || previous.sequence < 0 || !Array.isArray(previous.plugins)) throw new Error('invalid previous marketplace.json');
+      sequence = previous.sequence + 1;
+    }
+    // The public index describes the current catalog, not every version ever published.
+    const historyPath = join(input.outDir, '.publication-history.json');
+    const history: Array<{ name: string; version: string; sha256: string }> = existsSync(historyPath)
+      ? JSON.parse(readFileSync(historyPath, 'utf8')) : [];
+    if (!Array.isArray(history) || history.some(item => !item || typeof item.name !== 'string' ||
+        typeof item.version !== 'string' || typeof item.sha256 !== 'string' || !/^[a-f0-9]{64}$/.test(item.sha256))) {
+      throw new Error('invalid publication history');
+    }
+    if (!existsSync(historyPath) && previous && previous.sequence > 1) {
+      throw new Error('missing publication history: cannot prove version immutability');
+    }
+    const recordedHashes = new Map<string, string>();
+    const remember = (name: string, version: string, sha256: string) => {
+      const identity = JSON.stringify([name, version]);
+      const recorded = recordedHashes.get(identity);
+      if (recorded && recorded !== sha256) throw new Error(`version-immutable: ${name}@${version}`);
+      if (!recorded) {
+        recordedHashes.set(identity, sha256);
+        history.push({ name, version, sha256 });
+      }
+    };
+    const saved = history.splice(0);
+    for (const item of saved) remember(item.name, item.version, item.sha256);
+    for (const item of previous?.plugins ?? []) {
+      if (!item.artifact || typeof item.artifact.sha256 !== 'string') throw new Error('invalid previous marketplace.json');
+      remember(item.name, item.version, item.artifact.sha256);
+    }
+    const published: PublishResult['published'] = [];
+    const skipped: PublishResult['skipped'] = [];
+    const warnings: PublishResult['warnings'] = [];
+    const plugins: MarketplaceIndex['plugins'] = [];
+    const archives: Array<{ key: string; data: Uint8Array; name: string }> = [];
+    for (const dir of readdirSync(input.pluginsDir).sort()) {
+      const folder = join(input.pluginsDir, dir);
+      if (!lstatSync(folder).isDirectory()) continue;
+      currentName = dir;
+      currentVersion = undefined;
+      const manifestPath = join(folder, 'plugin.json');
+      const skip = (reason: string) => {
+        skipped.push({ dir, reason });
+        debug.log('market.publish', 'skipped', { name: dir, version: currentVersion, sequence, reason });
+      };
+      if (!existsSync(manifestPath)) { skip('missing-plugin.json'); continue; }
+      let manifest: Record<string, unknown>;
+      try { manifest = JSON.parse(readFileSync(manifestPath, 'utf8')); }
+      catch { skip('invalid-plugin.json'); continue; }
+      const ai = manifest?.extensions && typeof manifest.extensions === 'object'
+        ? (manifest.extensions as Record<string, unknown>)['ai.elanous'] : undefined;
+      if (!manifest || typeof manifest.name !== 'string' || typeof manifest.version !== 'string' ||
+          typeof manifest.description !== 'string' || !ai || typeof ai !== 'object' || Array.isArray(ai)) {
+        skip('invalid-plugin.json'); continue;
+      }
+      currentVersion = manifest.version;
+      if (!/^[a-z0-9-]{2,40}$/.test(manifest.name) || manifest.name !== dir ||
+          !/^[0-9]+\.[0-9]+\.[0-9]+(?:[-+][a-zA-Z0-9.-]+)?$/.test(manifest.version)) {
+        skip('invalid-plugin.json'); continue;
+      }
+      const { category, bundle, ...metadata } = ai as MarketplaceIndex['plugins'][number]['ai.elanous'] & { category?: string; bundle?: unknown };
+      if (!Array.isArray(metadata.capabilities) || !Array.isArray(metadata.connectors) ||
+          (category !== undefined && typeof category !== 'string')) {
+        skip('invalid-plugin.json'); continue;
+      }
+      if (metadata.pricing !== undefined && metadata.pricing?.model !== 'free') {
+        skip('paid-not-allowed-in-M0'); continue;
+      }
+      const bundleItem = (item: unknown): item is string | { from: string; as: string } => typeof item === 'string' ||
+        (!!item && typeof item === 'object' && !Array.isArray(item) && typeof (item as { from?: unknown }).from === 'string' &&
+          typeof (item as { as?: unknown }).as === 'string');
+      if (bundle !== undefined && (!Array.isArray(bundle) || !bundle.every(bundleItem))) {
+        skip('invalid-plugin.json'); continue;
+      }
+      const extraDirs: Array<{ from: string; as: string }> = [];
+      const bundled: string[] = [];
+      let bundleError: string | undefined;
+      if (bundle !== undefined && !input.bundleRoot) bundleError = 'bundle-root-missing';
+      if (bundle !== undefined && input.bundleRoot) {
+        const root = realpathSync(input.bundleRoot);
+        const inside = (path: string) => {
+          const rel = relative(root, path);
+          return rel !== '..' && !rel.startsWith(`..${posix.sep}`) && !isAbsolute(rel);
+        };
+        for (const entry of bundle as Array<string | { from: string; as: string }>) {
+          // A string names a skill folder (skills/<name>); { from, as } places any file or folder at `as`.
+          const item = typeof entry === 'string' ? entry : entry.from;
+          const candidate = resolve(root, item);
+          if (isAbsolute(item) || !inside(candidate)) { bundleError = 'bundle-path-outside-root'; break; }
+          if (!existsSync(candidate)) { bundleError = 'bundle-missing'; break; }
+          const from = realpathSync(candidate);
+          if (!inside(from)) { bundleError = 'bundle-path-outside-root'; break; }
+          if (typeof entry !== 'string') {
+            const stat = lstatSync(from);
+            if (stat.isFile()) { extraDirs.push({ from, as: entry.as }); bundled.push(entry.as); continue; }
+            if (!stat.isDirectory()) { bundleError = 'bundle-missing'; break; }
+          } else if (!lstatSync(from).isDirectory()) { bundleError = 'bundle-missing'; break; }
+          const checkContents = (path: string): boolean => readdirSync(path).every(name => {
+            const child = join(path, name);
+            const stat = lstatSync(child);
+            if (stat.isSymbolicLink()) return false;
+            const real = realpathSync(child);
+            if (!inside(real)) return false;
+            return !stat.isDirectory() || checkContents(child);
+          });
+          if (!checkContents(from)) { bundleError = 'bundle-path-outside-root'; break; }
+          if (typeof entry !== 'string') { extraDirs.push({ from, as: entry.as }); bundled.push(entry.as); continue; }
+          if (!['SKILL.md', 'skill.md'].some(file => {
+            const skill = join(from, file);
+            return existsSync(skill) && lstatSync(skill).isFile();
+          })) {
+            bundleError = 'bundle-not-a-skill'; break;
+          }
+          const name = basename(candidate);
+          extraDirs.push({ from, as: `skills/${name}` });
+          bundled.push(name);
+        }
+      }
+      // The loader registers only graphs listed in the manifest, so each listed path must ship in the package.
+      if (!bundleError && Array.isArray(metadata.graphs) && !metadata.graphs.every(graph => typeof graph === 'string' &&
+          (existsSync(join(folder, graph)) || extraDirs.some(extra => graph === extra.as || graph.startsWith(`${extra.as}/`))))) {
+        bundleError = 'graph-missing';
+      }
+      if (bundleError) { skip(bundleError); continue; }
+      // Third-party graphs may only use their own recipes (graphs/…/recipes.yaml next to the graph) or custom nodes;
+      // leaning on core code recipes is published but flagged. First-party packs may point at core recipes.
+      if ((ai as { trust?: unknown }).trust !== 'official' && Array.isArray(metadata.graphs)) {
+        const packagePath = (path: string): string | null => {
+          if (existsSync(join(folder, path))) return join(folder, path);
+          const extra = extraDirs.find(item => path === item.as || path.startsWith(`${item.as}/`));
+          return extra ? join(extra.from, path.slice(extra.as.length)) : null;
+        };
+        for (const graph of metadata.graphs) {
+          try {
+            const source = packagePath(graph);
+            if (!source || !lstatSync(source).isFile()) continue;
+            const spec = parseYaml(readFileSync(source, 'utf8')) as { nodes?: Array<{ recipe?: unknown }> } | null;
+            const recipesFile = packagePath(posix.join(posix.dirname(graph), 'recipes.yaml'));
+            const own = recipesFile && existsSync(recipesFile)
+              ? new Set(Object.keys((parseYaml(readFileSync(recipesFile, 'utf8')) as Record<string, unknown> | null) ?? {})) : new Set<string>();
+            const foreign = [...new Set((spec?.nodes ?? []).map(node => node?.recipe)
+              .filter((recipe): recipe is string => typeof recipe === 'string' && !own.has(recipe)))].sort();
+            if (foreign.length) {
+              warnings.push({ dir, graph, reason: 'third-party-core-recipe', recipes: foreign });
+              debug.log('market.publish', 'warning', { name: manifest.name, version: manifest.version, sequence, reason: 'third-party-core-recipe', graph, recipes: foreign });
+            }
+          } catch { /* A graph that cannot be read is the loader's validation error, not a publish warning. */ }
+        }
+      }
+      let archive: Uint8Array;
+      try { archive = packDirDeterministic(folder, { extraDirs }); }
+      catch (error) {
+        const message = error instanceof Error ? error.message : '';
+        if (message.startsWith('bundle-conflict')) { skip('bundle-conflict'); continue; }
+        throw error;
+      }
+      const sha256 = createHash('sha256').update(archive).digest('hex');
+      remember(manifest.name, manifest.version, sha256);
+      const key = `${manifest.name}/${manifest.version}/${sha256}.tgz`;
+      const source: MarketplaceIndex['plugins'][number]['source'] = input.source
+        ? { source: 'git-subdir', url: input.source.repoUrl, path: posix.join(input.source.basePath, dir), sha: input.source.sha }
+        : { source: 'local', path: `./plugins/${dir}` };
+      plugins.push({ name: manifest.name, source,
+        policy: { installation: 'AVAILABLE', authentication: 'ON_USE' },
+        category: category ?? 'Productivity', version: manifest.version,
+        description: manifest.description, artifact: { sha256, bytes: archive.length, key },
+        'ai.elanous': { ...metadata, pricing: metadata.pricing ?? { model: 'free' } },
+      });
+      archives.push({ key, data: archive, name: dir });
+      published.push({ name: manifest.name, version: manifest.version, sha256, bundled });
+      debug.log('market.publish', 'bundled', { name: manifest.name, version: manifest.version, skills: bundled });
+    }
+    const index: MarketplaceIndex = { name: input.market.name, interface: { displayName: input.market.displayName },
+      sequence, generatedAt: (input.now ?? new Date()).toISOString(), plugins };
+    const bytes = Buffer.from(JSON.stringify(index, null, 2) + '\n');
+    let signatureText: string;
+    let publicKey: string;
+    try {
+      signatureText = signIndex(bytes, input.key.privateKeyPem, input.key.keyId);
+      publicKey = createPublicKey(input.key.privateKeyPem).export({ format: 'der', type: 'spki' }).subarray(-32).toString('base64');
+    } catch {
+      throw new Error('invalid signing key');
+    }
+    const trustedKeys = [{ keyId: input.key.keyId, publicKey }];
+    const candidate = verifyIndex({ marketplaceBytes: bytes, signatureText, trustedKeys });
+    if (!candidate.ok) throw new Error(`index verification failed: ${candidate.reason}: ${candidate.detail}`);
+    for (const archive of archives) {
+      const destination = join(input.outDir, archive.key);
+      mkdirSync(join(destination, '..'), { recursive: true });
+      writeFileSync(destination, archive.data);
+      if (!input.source) {
+        const unpacked = join(input.outDir, 'plugins', archive.name);
+        rmSync(unpacked, { recursive: true, force: true });
+        unpackLocal(archive.data, unpacked);
+      }
+    }
+    mkdirSync(input.outDir, { recursive: true });
+    // Preserve the ledger before exposing an index that may later omit these versions.
+    writeFileSync(historyPath, JSON.stringify(history, null, 2) + '\n');
+    writeFileSync(indexPath, bytes);
+    if (!input.source) {
+      const codexIndex = join(input.outDir, '.agents', 'plugins', 'marketplace.json');
+      mkdirSync(join(codexIndex, '..'), { recursive: true });
+      writeFileSync(codexIndex, bytes);
+    }
+    writeFileSync(join(input.outDir, 'index.sig'), signatureText);
+    const verified = verifyIndex({ marketplaceBytes: readFileSync(indexPath),
+      signatureText: readFileSync(join(input.outDir, 'index.sig'), 'utf8'), trustedKeys });
+    if (!verified.ok) throw new Error(`index verification failed: ${verified.reason}: ${verified.detail}`);
+    for (const item of published) debug.log('market.publish', 'published', { name: item.name, version: item.version, sequence });
+    return { ok: true, sequence, published, skipped, warnings };
+  } catch (error) {
+    const rawReason = error instanceof Error ? error.message : 'unknown-error';
+    const reason = input.key.privateKeyPem && rawReason.includes(input.key.privateKeyPem) ? 'invalid signing key' : rawReason;
+    debug.log('market.publish', 'failed', { name: currentName, version: currentVersion, sequence, reason });
+    if (reason.startsWith('version-immutable')) throw new Error(reason);
+    throw new Error(`market publish failed: ${reason}`);
+  }
+}

package/src/market/signed-index.ts

@@ -0,0 +1,156 @@
+import { createHash, createPublicKey, generateKeyPairSync, sign, verify } from 'node:crypto';
+
+export interface MarketplaceIndex {
+  name: string;
+  interface: { displayName: string };
+  sequence: number;
+  generatedAt?: string;
+  plugins: Array<{
+    name: string;
+    source: { source: string; [key: string]: unknown };
+    policy?: { installation: string; authentication: string };
+    category?: string;
+    version: string;
+    description?: string;
+    artifact: { sha256: string; bytes: number; key: string };
+    'ai.elanous': {
+      capabilities: string[];
+      connectors: Array<{ id: string; kind: string; userConfig: Array<{ key: string; label: string; secret: boolean }> }>;
+      graphs?: string[];
+      vocab?: string[];
+      requires?: { elanous?: string; tools?: string[] };
+      pricing: { model: 'free' | 'one-time' | 'subscription'; amount?: number; currency?: string; period?: string };
+    };
+  }>;
+}
+
+export type VerifyIndexResult =
+  | { ok: true; keyId: string; sequence: number; index: MarketplaceIndex }
+  | { ok: false; reason: 'bad-signature' | 'unknown-key' | 'sequence-rollback' | 'malformed'; detail: string };
+
+const ED25519_SPKI_PREFIX = Buffer.from('302a300506032b6570032100', 'hex');
+const decoder = new TextDecoder('utf-8', { fatal: true });
+
+function record(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function string(value: unknown): value is string {
+  return typeof value === 'string';
+}
+
+function stringArray(value: unknown): value is string[] {
+  return Array.isArray(value) && value.every(string);
+}
+
+function rawBase64(value: unknown, length: number): Buffer | null {
+  if (!string(value) || !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(value)) return null;
+  const bytes = Buffer.from(value, 'base64');
+  return bytes.length === length && bytes.toString('base64') === value ? bytes : null;
+}
+
+function invalidIndex(value: unknown): string | null {
+  if (!record(value)) return 'index: expected object';
+  if (!string(value.name)) return 'name: expected string';
+  if (!record(value.interface) || !string(value.interface.displayName)) return 'interface.displayName: expected string';
+  if (!Number.isSafeInteger(value.sequence) || (value.sequence as number) < 0) return 'sequence: expected non-negative integer';
+  if (value.generatedAt !== undefined && !string(value.generatedAt)) return 'generatedAt: expected string';
+  if (!Array.isArray(value.plugins)) return 'plugins: expected array';
+
+  for (const [i, plugin] of value.plugins.entries()) {
+    const field = (name: string) => `plugins[${i}] (${record(plugin) && string(plugin.name) ? plugin.name : 'unnamed'}).${name}`;
+    if (!record(plugin)) return field('expected object');
+    if (!string(plugin.name)) return field('name: expected string');
+    if (!record(plugin.source) || !string(plugin.source.source)) return field('source.source: expected string');
+    if (plugin.policy !== undefined && (!record(plugin.policy) || !string(plugin.policy.installation) || !string(plugin.policy.authentication))) return field('policy: expected installation and authentication strings');
+    if (plugin.category !== undefined && !string(plugin.category)) return field('category: expected string');
+    if (!string(plugin.version)) return field('version: expected string');
+    if (plugin.description !== undefined && !string(plugin.description)) return field('description: expected string');
+    if (!record(plugin.artifact)) return field('artifact: expected object');
+    if (!string(plugin.artifact.sha256) || !/^[a-fA-F0-9]{64}$/.test(plugin.artifact.sha256)) return field('artifact.sha256: expected 64 hex characters');
+    if (!Number.isSafeInteger(plugin.artifact.bytes) || (plugin.artifact.bytes as number) < 0) return field('artifact.bytes: expected non-negative integer');
+    if (!string(plugin.artifact.key)) return field('artifact.key: expected string');
+    const ai = plugin['ai.elanous'];
+    if (!record(ai)) return field('ai.elanous: expected object');
+    if (!stringArray(ai.capabilities)) return field('ai.elanous.capabilities: expected string array');
+    if (!Array.isArray(ai.connectors)) return field('ai.elanous.connectors: expected array');
+    for (const [j, connector] of ai.connectors.entries()) {
+      if (!record(connector) || !string(connector.id) || !string(connector.kind) || !Array.isArray(connector.userConfig)) return field(`ai.elanous.connectors[${j}]: expected id, kind, userConfig`);
+      for (const [k, config] of connector.userConfig.entries()) {
+        if (!record(config) || !string(config.key) || !string(config.label) || typeof config.secret !== 'boolean') return field(`ai.elanous.connectors[${j}].userConfig[${k}]: expected key, label, secret`);
+      }
+    }
+    if (ai.graphs !== undefined && !stringArray(ai.graphs)) return field('ai.elanous.graphs: expected string array');
+    if (ai.vocab !== undefined && !stringArray(ai.vocab)) return field('ai.elanous.vocab: expected string array');
+    if (ai.requires !== undefined && (!record(ai.requires) || (ai.requires.elanous !== undefined && !string(ai.requires.elanous)) || (ai.requires.tools !== undefined && !stringArray(ai.requires.tools)))) return field('ai.elanous.requires: expected elanous string and tools string array');
+    if (!record(ai.pricing) || !['free', 'one-time', 'subscription'].includes(ai.pricing.model as string)) return field('ai.elanous.pricing.model: expected free, one-time or subscription');
+    if (ai.pricing.amount !== undefined && (typeof ai.pricing.amount !== 'number' || !Number.isFinite(ai.pricing.amount))) return field('ai.elanous.pricing.amount: expected number');
+    if (ai.pricing.currency !== undefined && !string(ai.pricing.currency)) return field('ai.elanous.pricing.currency: expected string');
+    if (ai.pricing.period !== undefined && !string(ai.pricing.period)) return field('ai.elanous.pricing.period: expected string');
+  }
+  return null;
+}
+
+export function verifyIndex(input: {
+  marketplaceBytes: Uint8Array;
+  signatureText: string;
+  trustedKeys: ReadonlyArray<{ keyId: string; publicKey: string }>;
+  lastSequence?: number;
+}): VerifyIndexResult {
+  const malformed = (detail: string): VerifyIndexResult => ({ ok: false, reason: 'malformed', detail });
+  let envelope: unknown;
+  try {
+    if (input.signatureText.includes('\n') || input.signatureText.includes('\r')) return malformed('index.sig: expected one JSON line');
+    envelope = JSON.parse(input.signatureText);
+  } catch {
+    return malformed('index.sig: invalid JSON');
+  }
+  if (!record(envelope) || !string(envelope.keyId) || !/^[a-fA-F0-9]{8}$/.test(envelope.keyId) || envelope.alg !== 'ed25519') {
+    return malformed('index.sig: expected 8-hex keyId and ed25519 alg');
+  }
+  const trusted = input.trustedKeys.find(key => key.keyId === envelope.keyId);
+  if (!trusted) return { ok: false, reason: 'unknown-key', detail: `index.sig.keyId: ${envelope.keyId}` };
+  const signature = rawBase64(envelope.sig, 64);
+  if (!signature) return malformed('index.sig.sig: expected base64 64-byte signature');
+  const publicKey = rawBase64(trusted.publicKey, 32);
+  if (!publicKey) return malformed(`trustedKeys[${envelope.keyId}].publicKey: expected base64 32-byte key`);
+  let valid: boolean;
+  try {
+    const key = createPublicKey({ key: Buffer.concat([ED25519_SPKI_PREFIX, publicKey]), format: 'der', type: 'spki' });
+    valid = verify(null, input.marketplaceBytes, key, signature);
+  } catch {
+    return malformed(`trustedKeys[${envelope.keyId}].publicKey: invalid Ed25519 key`);
+  }
+  if (!valid) return { ok: false, reason: 'bad-signature', detail: 'marketplace.json: signature verification failed' };
+
+  let index: unknown;
+  try {
+    index = JSON.parse(decoder.decode(input.marketplaceBytes));
+  } catch {
+    return malformed('marketplace.json: invalid UTF-8 or JSON');
+  }
+  const error = invalidIndex(index);
+  if (error) return malformed(`marketplace.json.${error}`);
+  const parsed = index as MarketplaceIndex;
+  if (input.lastSequence !== undefined && parsed.sequence < input.lastSequence) {
+    return { ok: false, reason: 'sequence-rollback', detail: `sequence ${parsed.sequence} < lastSequence ${input.lastSequence}` };
+  }
+  return { ok: true, keyId: envelope.keyId, sequence: parsed.sequence, index: parsed };
+}
+
+export function signIndex(marketplaceBytes: Uint8Array, privateKeyPem: string, keyId: string): string {
+  if (!/^[a-fA-F0-9]{8}$/.test(keyId)) throw new Error('keyId: expected 8 hex characters');
+  const signature = sign(null, marketplaceBytes, privateKeyPem);
+  return JSON.stringify({ keyId, alg: 'ed25519', sig: signature.toString('base64') });
+}
+
+export function generateIndexKeyPair(): { keyId: string; publicKey: string; privateKeyPem: string } {
+  const { publicKey, privateKey } = generateKeyPairSync('ed25519');
+  const der = publicKey.export({ format: 'der', type: 'spki' });
+  const raw = der.subarray(ED25519_SPKI_PREFIX.length);
+  return {
+    keyId: createHash('sha256').update(raw).digest('hex').slice(0, 8),
+    publicKey: raw.toString('base64'),
+    privateKeyPem: privateKey.export({ format: 'pem', type: 'pkcs8' }).toString(),
+  };
+}