feat: publish Dever core with project scaffolding and versioned AI skills

test/dever-cli-tests/external_workers/npm.rs

@@ -0,0 +1,119 @@
+use super::*;
+
+#[test]
+#[ignore = "requires the explicit official native npm build fixture at target/npm-build"]
+fn runs_official_npm_addon_from_offline_resources_and_threads() {
+    let temp = TemporaryDirectory::new();
+    let program = dever_core::check(&worker_sources(
+        "npm",
+        "worker/main.cjs",
+        "lib \"bufferutil@4.0.9\"",
+    ))
+    .unwrap();
+    let contract = program.external_worker_contracts().remove(0);
+    let workspace = Path::new(env!("CARGO_MANIFEST_DIR")).join("../..");
+    let prepared = workspace.join("target/npm-build");
+    let config: serde_json::Value =
+        serde_json::from_slice(&fs::read(prepared.join("config/setting.json")).unwrap()).unwrap();
+    let pack = fs::read(prepared.join(config["runtime_file"].as_str().unwrap())).unwrap();
+    let mut lock =
+        LockFile::decode(&fs::read(prepared.join("dependency/dever.lock")).unwrap()).unwrap();
+    let runtime = lock.libs[0].runtime.clone();
+    assert_eq!(sha(&pack), runtime.sha256);
+    let rejected = lock.builds[0]
+        .native_rejections
+        .keys()
+        .cloned()
+        .collect::<Vec<_>>();
+    assert!(
+        !rejected.is_empty(),
+        "official multi-platform prebuilds must be classified"
+    );
+    let entry = temp.path().join(&contract.entry);
+    fs::create_dir_all(entry.parent().unwrap()).unwrap();
+    let adapter = r#"const addon = require('bufferutil/build/Release/bufferutil.node');
+const {Worker} = require('node:worker_threads');
+const path = require('node:path');
+const rejected = __REJECTED__.map(name => path.join(__dirname, '..', name));
+exports.send = async payload => {
+  await new Promise((resolve, reject) => {
+    const worker = new Worker(`const {parentPort,workerData}=require('node:worker_threads'); const fs=require('node:fs'); parentPort.postMessage(workerData.every(path=>!fs.existsSync(path)));`, {eval:true,workerData:rejected});
+    worker.once('message', ok => ok ? resolve() : reject(new Error('unverified addon was installed')));
+    worker.once('error', reject);
+  });
+  const input=Buffer.from([payload.value]), output=Buffer.alloc(1), mask=Buffer.from([1,2,3,4]);
+  addon.mask(input,mask,output,0,1); addon.unmask(output,mask);
+  return {receipt:output[0]+1};
+};
+"#.replace("__REJECTED__",&serde_json::to_string(&rejected).unwrap());
+    fs::write(&entry, adapter).unwrap();
+    let mut resources = vec![resource(
+        format!(
+            "lib/runtime/npm/{}/runtime.pack",
+            dever_cli::toolchain::platform_identity()
+        ),
+        pack,
+    )];
+    for library in &mut lock.libs {
+        library.schema = contract.schema.clone();
+    }
+    for artifact in lock
+        .libs
+        .iter()
+        .flat_map(|lib| &lib.artifacts)
+        .chain(lock.builds.iter().map(|receipt| &receipt.output))
+    {
+        let bytes = fs::read(prepared.join("dependency/artifacts").join(&artifact.sha256)).unwrap();
+        assert_eq!(sha(&bytes), artifact.sha256);
+        resources.push(resource(artifact.path.clone(), bytes));
+    }
+    for asset in sandbox::assets(&workspace) {
+        let mut file = resource(asset.path, asset.bytes);
+        file.executable = asset.executable;
+        resources.push(file);
+    }
+    lock.workers.push(LockedWorker {
+        port: contract.port.clone(),
+        adapter: contract.adapter.clone(),
+        ecosystem: "npm".into(),
+        runtime: Some(runtime),
+        entry: contract.entry.clone(),
+        schema: contract.schema.clone(),
+        capabilities: contract.capabilities.clone(),
+        operations: contract.operations.clone(),
+        libs: contract
+            .libs
+            .iter()
+            .map(|spec| spec.parse().unwrap())
+            .collect(),
+    });
+    lock.write_atomic(temp.path()).unwrap();
+    let mut generated = workers::prepare(temp.path(), &program, &resources).unwrap();
+    let again = workers::prepare(temp.path(), &program, &resources).unwrap();
+    assert_eq!(
+        generated
+            .iter()
+            .map(|file| (&file.path, &file.sha256))
+            .collect::<Vec<_>>(),
+        again
+            .iter()
+            .map(|file| (&file.path, &file.sha256))
+            .collect::<Vec<_>>()
+    );
+    assert!(
+        generated
+            .iter()
+            .any(|file| file.path.ends_with("/build/Release/bufferutil.node")
+                && file.bytes.starts_with(b"\x7fELF"))
+    );
+    for rejected in &rejected {
+        assert!(!generated.iter().any(|file| file.path.ends_with(rejected)));
+    }
+    generated.extend(
+        resources
+            .into_iter()
+            .filter(|file| file.path.starts_with("sandbox/")),
+    );
+    fs::remove_file(entry).unwrap();
+    run_packaged_protocol(&temp, &contract, "npm", &generated);
+}