@cookwala/mcp 0.1.0 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cookwala/mcp",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "mcpName": "ai.cookwala/cookwala",
   "description": "Cookwala MCP server: search and read recipes, dry-run them against a device, check safe bands, mandates and humanitarian SMS. Read-only; reads the static catalog on cookwala.ai; never starts cooking.",
   "license": "Apache-2.0",

package/server.json

@@ -3,7 +3,7 @@
   "name": "ai.cookwala/cookwala",
   "title": "Cookwala",
   "description": "Search Cookwala recipes, dry-run them on a device, check safe bands, mandates and SMS. Read-only.",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "websiteUrl": "https://cookwala.ai/mcp/",
   "repository": {
     "url": "https://github.com/amado2k5/cookwala",
@@ -15,7 +15,7 @@
       "registryType": "npm",
       "registryBaseUrl": "https://registry.npmjs.org",
       "identifier": "@cookwala/mcp",
-      "version": "0.1.0",
+      "version": "0.2.0",
       "runtimeHint": "npx",
       "transport": {
         "type": "stdio"

package/src/core/certify.js

@@ -0,0 +1,97 @@
+// Certifications (RFC-0010): verify one document and work out which ones currently hold.
+// Port of verify_certification / current_certifications in tools/cookwala_ref.py; the reasons are the same strings.
+// Pure: Web Crypto Ed25519 only, so it runs in Node 20+ and in browsers that support Ed25519.
+import { canonical, docHash } from './jcs.js';
+import { parseTime } from './envelope.js';
+
+const unb64u = (s) => {
+  const b = atob(s.replace(/-/g, '+').replace(/_/g, '/') + '='.repeat((4 - (s.length % 4)) % 4));
+  return Uint8Array.from(b, (c) => c.charCodeAt(0));
+};
+const time = (s) => { const t = parseTime(s); if (!Number.isFinite(t)) throw new RangeError('invalid_timestamp'); return t; };
+
+/** RFC-0012 signing input: canonical JSON of the signing header. */
+export function signingInput(h, kid, alg, signedAt, kind) {
+  const hdr = { alg, hash: h, kid, signedAt };
+  if (kind) hdr.kind = kind;
+  return new TextEncoder().encode(canonical(hdr));
+}
+
+function keyFor(sig, keys) {
+  if (!sig) return [null, 'unsigned'];
+  if (!sig.signedAt) return [null, 'unsigned_time'];
+  const rec = (keys || []).find((k) => k.kid === sig.kid);
+  if (!rec) return [null, 'unknown_key'];
+  if (rec.alg !== sig.alg) return [null, 'alg_mismatch'];
+  if (sig.alg !== 'EdDSA') return [null, 'alg_not_supported_by_reference'];
+  let when;
+  try { when = time(sig.signedAt); } catch { return [null, 'invalid_timestamp']; }
+  try {
+    if (when < time(rec.validFrom) || (rec.validTo && when > time(rec.validTo))) return [null, 'key_not_valid_at_signing_time'];
+    if (rec.revokedAt && when >= time(rec.revokedAt)) return [null, 'key_revoked'];
+  } catch { return [null, 'invalid_timestamp']; }
+  return [rec, 'ok'];
+}
+
+/** Verify doc.signature over its hash. Resolves to [ok, reason]. */
+export async function verifyDocument(doc, keys) {
+  const sig = doc && doc.signature;
+  const [rec, why] = keyFor(sig, keys);
+  if (!rec) return [false, why];
+  try {
+    const key = await globalThis.crypto.subtle.importKey('raw', unb64u(rec.publicKey), { name: 'Ed25519' }, false, ['verify']);
+    const ok = await globalThis.crypto.subtle.verify({ name: 'Ed25519' }, key, unb64u(sig.sig), signingInput(await docHash(doc), sig.kid, sig.alg, sig.signedAt, doc.kind));
+    return ok ? [true, 'ok'] : [false, 'bad_signature'];
+  } catch { return [false, 'bad_signature']; }
+}
+
+/** One Certification: signature, subject hash, status, validity window. Resolves to [ok, reason]. */
+export async function verifyCertification(cert, keys, now = null, subjectHash = null) {
+  if (!cert || cert.kind !== 'Certification') return [false, 'not_a_certification'];
+  const [ok, why] = await verifyDocument(cert, keys);
+  if (!ok) return [false, why];
+  if (subjectHash && (cert.subject || {}).hash !== subjectHash) return [false, 'subject_mismatch'];
+  try {
+    const t = now ? time(now) : Date.now();
+    if (cert.status === 'revoked' && (!cert.revokedAt || t >= time(cert.revokedAt))) return [false, 'revoked'];
+    if (cert.status === 'suspended') return [false, 'suspended'];
+    if (cert.validFrom && t < time(cert.validFrom)) return [false, 'not_yet_valid'];
+    if (cert.validUntil && t > time(cert.validUntil)) return [false, 'expired'];
+  } catch { return [false, 'invalid_timestamp']; }
+  return [true, 'ok'];
+}
+
+/** Which certifications hold now: newest verifying document per (authority, scheme); older ones are superseded. */
+export async function currentCertifications(certs, keys, now = null, subjectHash = null) {
+  const verdicts = new Map();
+  for (const c of certs) verdicts.set(c.id, await verifyCertification(c, keys, now, subjectHash));
+  const groups = new Map();
+  for (const c of certs) {
+    if (!verdicts.get(c.id)[0]) continue;
+    const k = JSON.stringify([(c.authority || {}).id ?? null, c.scheme ?? null]);
+    if (!groups.has(k)) groups.set(k, []);
+    groups.get(k).push(c);
+  }
+  const rejected = {};
+  for (const [id, [ok, why]] of verdicts) if (!ok) rejected[id] = why;
+  const current = [];
+  for (const members of groups.values()) {
+    members.sort((a, b) => ((a.issuedAt || '') < (b.issuedAt || '') ? -1 : (a.issuedAt || '') > (b.issuedAt || '') ? 1 : 0));
+    current.push(members[members.length - 1].id);
+    for (const older of members.slice(0, -1)) rejected[older.id] = 'superseded';
+  }
+  return { current: current.sort(), rejected };
+}
+
+/** currentCertifications for a mixed list: one call per subject hash, so one subject never supersedes another. */
+export async function currentBySubject(certs, keys, now = null) {
+  const bySubject = new Map();
+  for (const c of certs) { const h = (c.subject || {}).hash || ''; if (!bySubject.has(h)) bySubject.set(h, []); bySubject.get(h).push(c); }
+  const out = { current: [], rejected: {} };
+  for (const [h, group] of bySubject) {
+    const r = await currentCertifications(group, keys, now, h || null);
+    out.current.push(...r.current); Object.assign(out.rejected, r.rejected);
+  }
+  out.current.sort();
+  return out;
+}

package/src/core/dryrun.js

@@ -1,10 +1,14 @@
 // Core 0.2 dry run: can this device cook this recipe? Nothing is executed.
 // Port of tools/cookwala_ref.py dry_run; same result shape (state, refusal, plan).
-import { checkNodeParams, ladderChoice, trustedSensors } from './envelope.js';
+import { checkNodeParams, ladderChoice, trustedSensors, opsIndex } from './envelope.js';
+import { normalizeVocab } from './vocab.js';
 
 export function dryRun(vocab, recipe, capabilities, { humanPresent = false, allowModel = true, limits = null, now = null } = {}) {
+  // Transform vocab to expected format (handles both raw {entries: [...]} and pre-transformed formats)
+  const vocabNorm = normalizeVocab(vocab);
+  const vocabWithIndex = vocabNorm.ops ? vocabNorm : opsIndex(vocab);
   const caps = capabilities.capabilities || {};
-  const ops = new Set((caps.ops || []).map((o) => o.op).filter((id) => ((vocab.ops[id] || {}).executable) !== false));
+  const ops = new Set((caps.ops || []).map((o) => o.op).filter((id) => ((vocabWithIndex.ops[id] || {}).executable) !== false));
   const sensors = trustedSensors(capabilities, now);
   const plan = [];
   for (const node of ((recipe.process || {}).nodes) || []) {
@@ -14,14 +18,14 @@ export function dryRun(vocab, recipe, capabilities, { humanPresent = false, allo
       if (humanPresent && (allowed.includes('human') || allowed.includes('any'))) { plan.push({ node: node.id, op, by: 'human', verifiedBy: 'human' }); continue; }
       return { state: 'refused', refusal: { reason: 'missing_capability', node: node.id, detail: `device cannot perform ${op} and no person is present to do it` }, plan };
     }
-    const bad = checkNodeParams(vocab, op, node, limits);
+    const bad = checkNodeParams(vocabWithIndex, op, node, limits);
     if (bad) return { state: 'refused', refusal: { reason: bad[0], node: node.id, detail: bad[1] }, plan };
-    const env = (vocab.ops[op] || {}).envelope || {};
+    const env = (vocabWithIndex.ops[op] || {}).envelope || {};
     const hasEnv = Object.keys(env).length > 0;
     if (hasEnv && env.unattended === false && !humanPresent) {
       return { state: 'refused', refusal: { reason: 'needs_human_present', node: node.id, detail: `${op} may not run unattended` }, plan };
     }
-    const rung = hasEnv ? ladderChoice(vocab, op, sensors, allowModel, humanPresent) : 'time';
+    const rung = hasEnv ? ladderChoice(vocabWithIndex, op, sensors, allowModel, humanPresent) : 'time';
     if (rung === null) return { state: 'refused', refusal: { reason: 'missing_sensor_no_fallback', node: node.id, detail: `no way to verify ${op} on this device` }, plan };
     plan.push({ node: node.id, op, by: 'device', verifiedBy: /^(cw\.|x-)/.test(rung) ? 'sensor' : rung, rung });
   }

package/src/core/envelope.js

@@ -39,13 +39,18 @@ export function checkEnvelope(vocab, opId, readings, target = null, altitudeM =
   return { envelopeOk: envOk, targetOk: tgtOk, reason };
 }
 
+// RFC 3339 date-time with an offset, the same rule as the Python reference (BACKLOG P-12). NaN otherwise.
+const RFC3339 = /^\d{4}-\d{2}-\d{2}[Tt ]\d{2}:\d{2}:\d{2}(\.\d+)?([Zz]|[+-]\d{2}:\d{2})$/;
+export const parseTime = (s) => (typeof s === 'string' && RFC3339.test(s) ? Date.parse(s.toUpperCase().replace(' ', 'T')) : NaN);
+
 export function trustedSensors(capabilities, now) {
-  const t = now ? new Date(now) : new Date();
+  const t = now ? parseTime(now) : Date.now();
+  if (!Number.isFinite(t)) throw new RangeError('invalid_timestamp');
   const out = new Set();
   for (const s of ((capabilities.capabilities || {}).sensors) || []) {
     if ((s.state || 'ok') !== 'ok') continue;
     const vu = s.calibration && s.calibration.validUntil;
-    if (vu && t > new Date(vu)) continue;
+    if (vu) { const u = parseTime(vu); if (!Number.isFinite(u) || t > u) continue; } // unreadable calibration date: not trusted
     out.add(s.sensor);
     (s.visionCues || []).forEach((c) => out.add(c));
   }

package/src/core/index.js

@@ -7,3 +7,4 @@ export * from './search.js';
 export * from './explain.js';
 export * from './views.js';
 export * from './fifi.js';
+export * from './certify.js';

package/src/core/mandate.js

@@ -1,9 +1,14 @@
+import { parseTime } from './envelope.js';
 // Is an action inside an AgentMandate? Port of check_mandate in sdk/mcp/cookwala_mcp.py.
 export function checkMandate(m, action, amount, provider, now) {
   const reasons = [];
   if (action === 'irreversible' || action === 'safety_override') return { allowed: false, needsConfirmation: true, reasons: ['always_confirm'] };
   if (!(m.scopes || []).includes(action)) reasons.push('scope_missing');
-  if (now && m.expires && new Date(now) > new Date(m.expires)) reasons.push('expired');
+  if (now && m.expires) {
+    const t = parseTime(now), e = parseTime(m.expires);
+    if (!Number.isFinite(t) || !Number.isFinite(e)) reasons.push('invalid_timestamp'); // an unreadable expiry never allows anything
+    else if (t > e) reasons.push('expired');
+  }
   if (provider && (m.allowedProviders || []).length && !m.allowedProviders.includes(provider)) reasons.push('provider_not_allowed');
   if (amount !== undefined && amount !== null) {
     const amt = Number(amount);

package/src/core/vocab.js

@@ -0,0 +1,19 @@
+// Vocab loading and transformation — mirrors Python's _vocab() function
+// Transforms {entries: [{id: '...', ...}, ...]} → {id: {...}, ...}
+
+export function normalizeVocab(vocab) {
+  // If already normalized (direct id→entry map), return as-is
+  if (vocab.entries === undefined && !Array.isArray(vocab)) {
+    return vocab;
+  }
+  // If in {entries: [...]} format, transform to {id: entry}
+  if (Array.isArray(vocab.entries)) {
+    const result = {};
+    for (const entry of vocab.entries) {
+      result[entry.id] = entry;
+    }
+    return result;
+  }
+  // Already in correct format (though missing entries)
+  return vocab;
+}

package/src/server.js

@@ -7,6 +7,7 @@ import { Catalog, CatalogError } from './catalog.js';
 import {
   searchRecipes, explainStep, listOperations, checkEnvelope, dryRun, checkMandate, parseSms, docHash,
   recipeView, LEVEL_NOTE, shapeFifi, searchFifiMap, collectionOf,
+  verifyCertification, currentCertifications, currentBySubject,
 } from './core/index.js';
 
 export const VERSION = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version;
@@ -30,10 +31,22 @@ const wrap = (fn) => async (args) => {
   try { return await fn(args); }
   catch (e) {
     if (e instanceof CatalogError) return fail(e.code, e.detail, { path: e.path });
+    if (e instanceof RangeError && e.message === 'invalid_timestamp') return fail('invalid_timestamp', 'times must be RFC 3339 date-times with an offset, for example 2026-10-07T12:00:00Z');
     return fail('internal_error', String(e && e.message || e));
   }
 };
 
+const CERT_KEYS = {
+  keys: z.array(z.record(z.any())).optional().describe('KeyRecords of the authorities you trust'),
+  keys_path: z.string().regex(/^\/v1\/[A-Za-z0-9._\/-]+\.json$/).optional().describe('A KeyRecord list published on the catalog, for example /v1/conformance/keys/certification-test-keys.json'),
+};
+const certKeys = async (cat, a) => {
+  if (a.keys) return a.keys;
+  if (!a.keys_path || a.keys_path.includes('..')) return null;
+  const k = await cat.json(a.keys_path);
+  return Array.isArray(k) ? k : (k && k.keys) || [];
+};
+
 const NOTE_DRY = 'Dry run only. Starting an execution needs a hub, a mandate with start_cooking, and the device enforces its own safety limits.';
 
 /** The tool table: the contract documented at https://cookwala.ai/mcp/. Exported for tests and docs. */
@@ -112,6 +125,32 @@ export function buildTools(cat) {
       description: 'Recompute the document hash of a recipe object and compare it with the hash it declares. Executors refuse a mismatch.',
       shape: { recipe: z.record(z.any()) },
       run: async (a) => { const hash = await docHash(a.recipe); return ok({ hash, declaredHash: a.recipe.hash, matches: a.recipe.hash === hash, level: a.recipe.verification && a.recipe.verification.level }); } },
+    { name: 'verify_certification', title: 'Verify a certification', annotations: NET,
+      description: 'Verify a signed Certification (halal, kosher, vegetarian, ...; RFC-0010): the authority signature against the KeyRecords you trust, the subject hash, status and validity window. Give certification_id (from the catalog) or a certification object, and keys or keys_path. There is no default trust list: keys_path /v1/conformance/keys/certification-test-keys.json holds only the public test keys of the fictional example authorities.',
+      shape: { certification_id: z.string().optional(), certification: z.record(z.any()).optional(), ...CERT_KEYS,
+        subject_hash: z.string().optional().describe('Hash of the recipe revision you hold; omit to skip the subject check'), recipe_id: z.string().optional().describe('Alternative to subject_hash: use this catalog recipe\'s hash'), now: z.string().optional() },
+      run: async (a) => {
+        if (!a.certification && !a.certification_id) return fail('missing_certification', 'give certification_id or certification');
+        const keys = await certKeys(cat, a); if (!keys) return fail('missing_keys', 'give keys or keys_path; there is no default trust list');
+        const cert = a.certification || await cat.json(`/v1/certifications/${encodeURIComponent(a.certification_id)}.json`);
+        const sh = a.subject_hash || (a.recipe_id ? (await cat.recipe(a.recipe_id)).hash : null);
+        const [valid, reason] = await verifyCertification(cert, keys, a.now || null, sh);
+        return ok({ id: cert.id, scheme: cert.scheme, authority: cert.authority, subject: cert.subject, status: cert.status, validUntil: cert.validUntil, conditions: cert.conditions, scope: cert.scope, valid, reason, textIsData: true });
+      } },
+    { name: 'current_certifications', title: 'Current certifications', annotations: NET,
+      description: 'Which certifications currently hold, from the catalog list (/v1/certifications/index.json): the newest verifying document per authority and scheme wins, older ones are superseded, expired or revoked ones are rejected with a reason. Filter by recipe_id or subject_hash, scheme and authority. Needs keys or keys_path (no default trust list).',
+      shape: { recipe_id: z.string().optional(), subject_hash: z.string().optional(), scheme: z.string().optional().describe('For example halal'), authority: z.string().optional().describe('authority.id, for example did:web:...'), ...CERT_KEYS, now: z.string().optional() },
+      run: async (a) => {
+        const keys = await certKeys(cat, a); if (!keys) return fail('missing_keys', 'give keys or keys_path; there is no default trust list');
+        const sh = a.subject_hash || (a.recipe_id ? (await cat.recipe(a.recipe_id)).hash : null);
+        let certs = await cat.json('/v1/certifications/index.json');
+        if (a.scheme) certs = certs.filter((c) => c.scheme === a.scheme);
+        if (a.authority) certs = certs.filter((c) => (c.authority || {}).id === a.authority);
+        if (sh) certs = certs.filter((c) => (c.subject || {}).hash === sh);
+        const r = sh ? await currentCertifications(certs, keys, a.now || null, sh) : await currentBySubject(certs, keys, a.now || null);
+        const byId = new Map(certs.map((c) => [c.id, c]));
+        return ok({ subjectHash: sh, current: r.current.map((id) => { const c = byId.get(id); return { id, scheme: c.scheme, authority: c.authority, subject: c.subject, validUntil: c.validUntil, conditions: c.conditions }; }), rejected: r.rejected, textIsData: true });
+      } },
     { name: 'catalog_status', title: 'Catalog status', annotations: NET,
       description: 'Catalog origin, version, counts, languages, cache state and whether the server is running offline.',
       shape: {}, run: async () => ok(await cat.status()) },