ultra-builder-pro-cli 0.7.0 → 0.9.0

package/adapters/_shared/tests/provenance.test.cjs

@@ -0,0 +1,133 @@
+'use strict';
+
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { execFileSync } = require('node:child_process');
+
+const provenance = require('../provenance.cjs');
+
+function fixture() {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-provenance-'));
+  fs.mkdirSync(path.join(root, 'runtime'), { recursive: true });
+  fs.mkdirSync(path.join(root, 'hooks'), { recursive: true });
+  fs.writeFileSync(path.join(root, 'runtime', 'launch.cjs'), 'module.exports = true;\n');
+  fs.writeFileSync(path.join(root, 'hooks', 'hooks.json'), '{}\n');
+  const file = path.join(root, 'provenance.json');
+  provenance.writeProvenance({
+    file,
+    adapter: 'claude',
+    packageInfo: { name: 'ultra-builder-pro-cli', version: '1.2.3' },
+    repository: 'https://example.test/ultra-builder-pro',
+    sourceCommit: '0123456789abcdef0123456789abcdef01234567',
+    roots: { plugin: root },
+    assets: [
+      { root: 'plugin', path: 'hooks/hooks.json' },
+      { root: 'plugin', path: 'runtime/launch.cjs' },
+    ],
+    contracts: {
+      hooks_manifest: { root: 'plugin', path: 'hooks/hooks.json' },
+      mcp_launcher: { root: 'plugin', path: 'runtime/launch.cjs' },
+    },
+  });
+  return { root, file };
+}
+
+test('writeProvenance + inspectProvenance produce a normalized healthy report', () => {
+  const fx = fixture();
+  try {
+    const manifest = JSON.parse(fs.readFileSync(fx.file, 'utf8'));
+    assert.equal(manifest.schema_version, 1);
+    assert.equal(manifest.adapter, 'claude');
+    assert.equal(manifest.package.version, '1.2.3');
+    assert.equal(manifest.source.repository, 'https://example.test/ultra-builder-pro');
+    assert.match(manifest.content.digest, /^[0-9a-f]{64}$/);
+    assert.deepEqual(manifest.assets.map((asset) => asset.path), [
+      'hooks/hooks.json', 'runtime/launch.cjs',
+    ]);
+
+    const report = provenance.inspectProvenance({
+      file: fx.file,
+      expectedAdapter: 'claude',
+      expectedPackageVersion: '1.2.3',
+    });
+    assert.equal(report.status, 'healthy');
+    assert.deepEqual(report.issues, []);
+    assert.equal(report.checks.assets.checked, 2);
+    assert.equal(report.checks.contracts.checked, 2);
+  } finally {
+    fs.rmSync(fx.root, { recursive: true, force: true });
+  }
+});
+
+test('inspectProvenance detects content drift and missing contract targets', () => {
+  const fx = fixture();
+  try {
+    fs.writeFileSync(path.join(fx.root, 'runtime', 'launch.cjs'), 'tampered\n');
+    fs.unlinkSync(path.join(fx.root, 'hooks', 'hooks.json'));
+    const report = provenance.inspectProvenance({
+      file: fx.file,
+      expectedAdapter: 'claude',
+      expectedPackageVersion: '1.2.3',
+    });
+    assert.equal(report.status, 'degraded');
+    assert.ok(report.issues.some((issue) => issue.code === 'ASSET_HASH_MISMATCH'));
+    assert.ok(report.issues.some(
+      (issue) => issue.code === 'CONTRACT_TARGET_MISSING' && issue.contract === 'hooks_manifest',
+    ));
+  } finally {
+    fs.rmSync(fx.root, { recursive: true, force: true });
+  }
+});
+
+test('inspectProvenance fails closed for missing, corrupt, or mismatched manifests', () => {
+  const fx = fixture();
+  try {
+    const mismatch = provenance.inspectProvenance({
+      file: fx.file,
+      expectedAdapter: 'codex',
+      expectedPackageVersion: '9.9.9',
+    });
+    assert.equal(mismatch.status, 'degraded');
+    assert.ok(mismatch.issues.some((issue) => issue.code === 'ADAPTER_MISMATCH'));
+    assert.ok(mismatch.issues.some((issue) => issue.code === 'PACKAGE_VERSION_MISMATCH'));
+
+    fs.writeFileSync(fx.file, 'not-json');
+    const corrupt = provenance.inspectProvenance({ file: fx.file });
+    assert.equal(corrupt.status, 'degraded');
+    assert.equal(corrupt.issues[0].code, 'PROVENANCE_INVALID');
+
+    fs.unlinkSync(fx.file);
+    const missing = provenance.inspectProvenance({ file: fx.file });
+    assert.equal(missing.status, 'missing');
+    assert.equal(missing.issues[0].code, 'PROVENANCE_MISSING');
+  } finally {
+    fs.rmSync(fx.root, { recursive: true, force: true });
+  }
+});
+
+test('packageSource never attributes an enclosing consumer repository commit to the package', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-provenance-source-'));
+  try {
+    execFileSync('git', ['init', '-q'], { cwd: root });
+    execFileSync('git', ['config', 'user.email', 'test@ubp.dev'], { cwd: root });
+    execFileSync('git', ['config', 'user.name', 'ubp-test'], { cwd: root });
+    fs.writeFileSync(path.join(root, 'README.md'), '# consumer\n');
+    execFileSync('git', ['add', 'README.md'], { cwd: root });
+    execFileSync('git', ['commit', '-q', '-m', 'seed'], { cwd: root });
+    const packageRoot = path.join(root, 'node_modules', 'ultra-builder-pro-cli');
+    fs.mkdirSync(packageRoot, { recursive: true });
+    fs.writeFileSync(path.join(packageRoot, 'package.json'), JSON.stringify({
+      name: 'ultra-builder-pro-cli',
+      version: '1.2.3',
+      repository: { url: 'https://example.test/ultra-builder-pro' },
+    }));
+
+    const source = provenance.packageSource(packageRoot);
+    assert.equal(source.sourceCommit, null);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});

package/adapters/_shared/tests/runtime-assets.test.cjs

@@ -62,7 +62,10 @@ test('runtime asset manifest exposes only Ultra-owned core and internal skills',
   assert.deepEqual(COLLAB_SKILLS_BY_RUNTIME.opencode, [
     'cc-collab', 'codex-collab', 'ultra-verify',
   ]);
-  assert.deepEqual(SUPPORTED_RUNTIMES, ['claude', 'opencode', 'codex']);
+  assert.deepEqual(COLLAB_SKILLS_BY_RUNTIME.kimi, [
+    'cc-collab', 'codex-collab', 'ultra-verify',
+  ]);
+  assert.deepEqual(SUPPORTED_RUNTIMES, ['claude', 'opencode', 'codex', 'kimi']);
 
   for (const runtime of SUPPORTED_RUNTIMES) {
     const names = skillsForRuntime(runtime);

package/adapters/claude.js

@@ -15,6 +15,7 @@ const {
   writeAtomic,
 } = require('./_shared/file-ops.cjs');
 const { buildMcpRuntime } = require('./_shared/codex-assets.cjs');
+const provenance = require('./_shared/provenance.cjs');
 const {
   CORE_PUBLIC_SKILLS,
   WORKFLOW_HOOK_FILES,
@@ -26,6 +27,7 @@ const MCP_SERVER_NAME = PLUGIN_NAME;
 const SOURCE_TAG = 'ubp';
 const SENTINEL_KEY = '_ubp_manifest';
 const COMMAND_NAMES = CORE_PUBLIC_SKILLS.filter((name) => name !== 'ultra-review');
+const PROVENANCE_FILE = 'provenance.json';
 
 function resolveTarget(ctx = {}) {
   if (ctx.configDir) return ctx.configDir;
@@ -155,9 +157,39 @@ function install(ctx = {}) {
     license: pkg.license || 'MIT',
   }, null, 2) + '\n');
   markManaged(target, { adapter: 'claude', plugin: PLUGIN_NAME });
+  const source = provenance.packageSource(repoRoot);
+  const provenanceFile = path.join(target, PROVENANCE_FILE);
+  report.provenance = provenance.writeProvenance({
+    file: provenanceFile,
+    adapter: 'claude',
+    ...source,
+    roots: { plugin: target },
+    assets: provenance.assetRefsForTree('plugin', target, {
+      exclude: ['.ubp-managed', PROVENANCE_FILE],
+    }),
+    contracts: {
+      plugin_manifest: { root: 'plugin', path: '.claude-plugin/plugin.json' },
+      mcp_registration: { root: 'plugin', path: '.mcp.json' },
+      mcp_launcher: { root: 'plugin', path: 'runtime/launch.cjs' },
+      hooks_manifest: { root: 'plugin', path: 'hooks/hooks.json' },
+      checkpoint_hook: { root: 'plugin', path: 'hooks/workflow_checkpoint.py' },
+      resume_hook: { root: 'plugin', path: 'hooks/workflow_resume.py' },
+    },
+  });
+  report.provenance.file = provenanceFile;
   return report;
 }
 
+function doctor(ctx = {}) {
+  const repoRoot = resolveRepoRoot(ctx);
+  const source = provenance.packageSource(repoRoot);
+  return provenance.inspectProvenance({
+    file: path.join(resolvePluginRoot(ctx), PROVENANCE_FILE),
+    expectedAdapter: 'claude',
+    expectedPackageVersion: source.packageInfo.version,
+  });
+}
+
 function uninstall(ctx = {}) {
   const target = resolvePluginRoot(ctx);
   const report = { target, removed: {}, config: { updated: false } };
@@ -179,4 +211,5 @@ module.exports = {
   resolvePluginRoot,
   install,
   uninstall,
+  doctor,
 };

package/adapters/codex.js

@@ -33,6 +33,7 @@ const {
   buildPlugin,
   installAgents,
 } = require('./_shared/codex-assets.cjs');
+const provenance = require('./_shared/provenance.cjs');
 
 const MCP_SERVER_NAME = PLUGIN_NAME;
 const SOURCE_TAG = 'ubp';
@@ -40,6 +41,7 @@ const MARKER_BEGIN = '# >>> ultra-builder-pro managed block — do not edit by h
 const MARKER_END = '# <<< ultra-builder-pro managed block';
 const RUNTIME_MANIFEST_DIR = 'ultra-builder-pro';
 const RUNTIME_MANIFEST_FILE = 'install-manifest.json';
+const PROVENANCE_FILE = 'provenance.json';
 const HOOK_ADAPTER_RELATIVE = path.join('hooks', 'adapters', 'codex.py');
 
 function resolveTarget(ctx = {}) {
@@ -355,6 +357,30 @@ function install(ctx = {}) {
     agents: agents.installed,
     hookCacheVersions,
   });
+  const source = provenance.packageSource(repoRoot);
+  const provenanceFile = path.join(configDir, RUNTIME_MANIFEST_DIR, PROVENANCE_FILE);
+  const provenanceManifest = provenance.writeProvenance({
+    file: provenanceFile,
+    adapter: 'codex',
+    ...source,
+    roots: { plugin: pluginRoot, config: configDir },
+    assets: [
+      ...provenance.assetRefsForTree('plugin', pluginRoot, {
+        exclude: ['.ubp-managed'],
+      }),
+      ...agents.installed.map((file) => ({ root: 'config', path: path.join('agents', file) })),
+      { root: 'config', path: path.join(RUNTIME_MANIFEST_DIR, RUNTIME_MANIFEST_FILE) },
+    ],
+    contracts: {
+      plugin_manifest: { root: 'plugin', path: '.codex-plugin/plugin.json' },
+      mcp_registration: { root: 'plugin', path: '.mcp.json' },
+      mcp_launcher: { root: 'plugin', path: 'runtime/launch.cjs' },
+      hooks_manifest: { root: 'plugin', path: 'hooks/hooks.json' },
+      hook_adapter: { root: 'plugin', path: HOOK_ADAPTER_RELATIVE },
+      runtime_manifest: { root: 'config', path: path.join(RUNTIME_MANIFEST_DIR, RUNTIME_MANIFEST_FILE) },
+    },
+  });
+  provenanceManifest.file = provenanceFile;
 
   return {
     target: configDir,
@@ -365,10 +391,70 @@ function install(ctx = {}) {
     hookCompatibility,
     legacy,
     manifestFile,
+    provenance: provenanceManifest,
     config: { updated: legacy.configUpdated },
   };
 }
 
+function doctor(ctx = {}) {
+  const configDir = resolveTarget(ctx);
+  const pluginRoot = resolvePluginRoot(ctx);
+  const repoRoot = resolveRepoRoot(ctx);
+  const marketplaceFile = resolveMarketplaceFile(ctx);
+  const source = provenance.packageSource(repoRoot);
+  const report = provenance.inspectProvenance({
+    file: path.join(configDir, RUNTIME_MANIFEST_DIR, PROVENANCE_FILE),
+    expectedAdapter: 'codex',
+    expectedPackageVersion: source.packageInfo.version,
+  });
+
+  let runtimeManifest = null;
+  try {
+    runtimeManifest = readRuntimeManifest(configDir);
+  } catch (error) {
+    report.issues.push({ code: 'RUNTIME_MANIFEST_INVALID', message: error.message });
+  }
+  const runtimeManifestOk = runtimeManifest?.source === SOURCE_TAG
+    && runtimeManifest.adapter === 'codex'
+    && runtimeManifest.plugin?.root === pluginRoot
+    && typeof runtimeManifest.plugin?.version === 'string';
+  if (!runtimeManifestOk && !report.issues.some((entry) => entry.code === 'RUNTIME_MANIFEST_INVALID')) {
+    report.issues.push({ code: 'RUNTIME_MANIFEST_INVALID', path: runtimeManifestFile(configDir) });
+  }
+  report.checks.runtime_manifest = { status: runtimeManifestOk ? 'pass' : 'fail' };
+
+  let marketplaceOk = false;
+  try {
+    const marketplace = loadMarketplace(marketplaceFile);
+    const entry = marketplace.plugins.find((plugin) => plugin?.name === PLUGIN_NAME);
+    marketplaceOk = entry?.source?.source === 'local'
+      && entry.source.path === `./plugins/${PLUGIN_NAME}`;
+  } catch (error) {
+    report.issues.push({ code: 'MARKETPLACE_REGISTRATION_INVALID', message: error.message });
+  }
+  if (!marketplaceOk && !report.issues.some((entry) => entry.code === 'MARKETPLACE_REGISTRATION_INVALID')) {
+    report.issues.push({ code: 'MARKETPLACE_REGISTRATION_INVALID', path: marketplaceFile });
+  }
+  report.checks.marketplace = { status: marketplaceOk ? 'pass' : 'fail' };
+
+  let hookTargetsOk = runtimeManifestOk;
+  if (runtimeManifestOk) {
+    const cacheRoot = pluginCacheRoot(configDir, runtimeManifest.marketplace?.name || 'personal');
+    const currentCacheRequired = shouldRunPluginCli(ctx);
+    for (const version of runtimeManifest.hook_cache_versions || []) {
+      if (version === runtimeManifest.plugin.version && !currentCacheRequired) continue;
+      const adapter = path.join(cacheRoot, version, HOOK_ADAPTER_RELATIVE);
+      if (!fs.existsSync(adapter)) {
+        hookTargetsOk = false;
+        report.issues.push({ code: 'HOOK_TARGET_MISSING', version, path: adapter });
+      }
+    }
+  }
+  report.checks.hook_targets = { status: hookTargetsOk ? 'pass' : 'fail' };
+  if (report.status !== 'missing') report.status = report.issues.length === 0 ? 'healthy' : 'degraded';
+  return report;
+}
+
 function removeManagedAgents(configDir, manifest) {
   const agentRoot = path.join(configDir, 'agents');
   const requested = manifest && Array.isArray(manifest.agents)
@@ -440,6 +526,7 @@ module.exports = {
   resolveMarketplaceFile,
   install,
   uninstall,
+  doctor,
   _internal: {
     stripManagedBlock,
     hasManagedBlock,