The design language that makes your AI harness better at design.
JavaScript
#!/usr/bin/env node
// Local release signing. Private key material travels from op through a pipe
// into crypto, never through argv, environment values, logs or temporary files.
import { createHash, createPrivateKey, createPublicKey, sign, verify } from 'node:crypto';
import { execFileSync } from 'node:child_process';
import { readFileSync, writeFileSync, statSync } from 'node:fs';
import { fileURLToPath } from 'node:url';
import path from 'node:path';
export const VERSION_PATTERN = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
const MAX_BUNDLE_BYTES = 256 * 1024 * 1024;
const repoRoot = fileURLToPath(new URL('../', import.meta.url));
function localSetting(name) {
try {
return execFileSync('git', ['config', '--local', '--get', name], {
cwd: repoRoot, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'],
}).trim();
} catch { return undefined; }
}
export function publicKeyHex(key) {
if (key.asymmetricKeyType !== 'ed25519') throw new Error('Signing requires an Ed25519 key.');
const jwk = key.export({ format: 'jwk' });
return Buffer.from(jwk.x, 'base64url').toString('hex');
}
// Shared wire format with crates/skills/src/bundle_signature.rs. UTF-8, LF,
// trailing LF. Sign fields explicitly so JSON whitespace/order is irrelevant.
export function signaturePayload({ keyId, version, artifact, size, sha256 }) {
return Buffer.from(`impeccable-skill-bundle-v1\n${keyId}\nskill-v${version}\n${artifact}\n${size}\n${sha256}\n`);
}
export function readTrustedKeys() {
return JSON.parse(readFileSync(new URL('./bundle-signing-keys.json', import.meta.url), 'utf8'));
}
export function signBundle(bytes, version, privateKey, trustedKeys) {
if (typeof version !== 'string' || version.length > 128 || !VERSION_PATTERN.test(version)) throw new Error('Invalid skill version for signing.');
if (!bytes.length || bytes.length > MAX_BUNDLE_BYTES) throw new Error('Invalid bundle size for signing.');
const publicKey = createPublicKey(privateKey);
const publicHex = publicKeyHex(publicKey);
const keyId = Object.keys(trustedKeys).find(id => trustedKeys[id] === publicHex);
if (!keyId || !/^[a-z0-9-]{1,64}$/.test(keyId)) {
throw new Error('The signing key is not in the trusted bundle keyring.');
}
const envelope = {
schema: 1, keyId, version, artifact: 'universal.zip', size: bytes.length,
sha256: createHash('sha256').update(bytes).digest('hex'),
};
const payload = signaturePayload(envelope);
const signature = sign(null, payload, privateKey);
if (!verify(null, payload, publicKey, signature)) throw new Error('Signature self-check failed.');
return { ...envelope, signature: signature.toString('hex') };
}
function readFrom1Password(reference, account) {
return execFileSync('op', ['read', reference, '--no-newline', ...(account ? ['--account', account] : [])], {
stdio: ['ignore', 'pipe', 'pipe'], timeout: 120000, maxBuffer: 16384,
});
}
export function signReleaseBundle({ zipPath, version, trustedKeys = readTrustedKeys(),
secretReference = process.env.IMPECCABLE_SIGNING_KEY_REF ?? localSetting('impeccable.signingKeyRef'),
account = process.env.OP_ACCOUNT ?? localSetting('impeccable.signingAccount'), readSecret = readFrom1Password }) {
if (!secretReference?.startsWith('op://')) {
throw new Error('Set IMPECCABLE_SIGNING_KEY_REF to the 1Password private-key reference (op://vault/item/field).');
}
if (typeof version !== 'string' || version.length > 128 || !VERSION_PATTERN.test(version)) throw new Error('Invalid skill version for signing.');
if (statSync(zipPath).size > MAX_BUNDLE_BYTES) throw new Error('Invalid bundle size for signing.');
const bytes = readFileSync(zipPath);
let pem;
try {
const secret = readSecret(secretReference, account);
pem = Buffer.isBuffer(secret) ? secret : Buffer.from(secret);
} catch {
// Child-process exceptions can contain stdout/stderr. Never propagate them.
throw new Error('Could not read the signing key from 1Password. Check CLI integration and unlock the vault.');
}
let privateKey;
try {
privateKey = createPrivateKey(pem);
} catch {
throw new Error('The 1Password field is not a valid PKCS#8 private key.');
} finally {
pem.fill(0);
}
const envelope = signBundle(bytes, version, privateKey, trustedKeys);
const output = `${zipPath}.sig.json`;
writeFileSync(output, `${JSON.stringify(envelope, null, 2)}\n`);
return output;
}
if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
try {
const [version, zipPath, ...extra] = process.argv.slice(2);
if (!zipPath || extra.length || path.basename(zipPath) !== 'universal.zip') {
throw new Error('Usage: node scripts/sign-bundle.mjs <skill-version> <path/to/universal.zip>');
}
console.log(`Signed ${signReleaseBundle({ zipPath, version })}`);
} catch (error) {
console.error(error.message);
process.exitCode = 1;
}
}