sema-cli 0.1.0

package/experiments/spike-shell-stream/shared/crypto.js

@@ -0,0 +1,138 @@
+const crypto = require("node:crypto");
+
+/**
+ * Generate X25519 key pair for E2E encryption.
+ * @returns {{ privateKey: KeyObject, publicKey: KeyObject }}
+ */
+function generateKeyPair() {
+  return crypto.generateKeyPairSync("x25519");
+}
+
+/**
+ * Export public key to base64-encoded SPKI DER format for transmission.
+ * @param {KeyObject} publicKey
+ * @returns {string} base64-encoded public key
+ */
+function exportPublicKey(publicKey) {
+  return publicKey.export({ type: "spki", format: "der" }).toString("base64");
+}
+
+/**
+ * Export private key to base64-encoded PKCS8 DER format for transmission.
+ * @param {KeyObject} privateKey
+ * @returns {string} base64-encoded private key
+ */
+function exportPrivateKey(privateKey) {
+  return privateKey.export({ type: "pkcs8", format: "der" }).toString("base64");
+}
+
+/**
+ * Import public key from base64-encoded SPKI DER format.
+ * @param {string} base64 - base64-encoded public key
+ * @returns {KeyObject}
+ */
+function importPublicKey(base64) {
+  return crypto.createPublicKey({
+    key: Buffer.from(base64, "base64"),
+    format: "der",
+    type: "spki",
+  });
+}
+
+/**
+ * Import private key from base64-encoded PKCS8 DER format.
+ * @param {string} base64 - base64-encoded private key
+ * @returns {KeyObject}
+ */
+function importPrivateKey(base64) {
+  return crypto.createPrivateKey({
+    key: Buffer.from(base64, "base64"),
+    format: "der",
+    type: "pkcs8",
+  });
+}
+
+/**
+ * Derive shared secret using X25519 Diffie-Hellman.
+ * @param {KeyObject} privateKey - own private key
+ * @param {KeyObject} peerPublicKey - peer's public key
+ * @returns {Buffer} 32-byte shared secret
+ */
+function deriveSharedSecret(privateKey, peerPublicKey) {
+  return crypto.diffieHellman({ privateKey, publicKey: peerPublicKey });
+}
+
+/**
+ * Derive AES-256 key from shared secret using HKDF.
+ * Salt and info are explicit Buffers to ensure consistency with Web Crypto API.
+ * @param {Buffer} sharedSecret - X25519 shared secret
+ * @param {Buffer} [salt] - HKDF salt (default: "sema-e2e")
+ * @returns {Buffer} 32-byte AES-256 key
+ */
+function deriveAesKey(sharedSecret, salt = Buffer.from("sema-e2e", "utf8")) {
+  const info = Buffer.from("aes-256-key", "utf8");
+  // hkdfSync returns ArrayBuffer, must convert to Buffer for createCipheriv
+  return Buffer.from(crypto.hkdfSync("sha256", sharedSecret, salt, info, 32));
+}
+
+/**
+ * Encrypt plaintext using AES-256-GCM.
+ * @param {string} plaintext - UTF-8 plaintext
+ * @param {Buffer} key - 32-byte AES-256 key
+ * @returns {{ iv: string, ct: string, tag: string }} base64-encoded iv, ciphertext, and auth tag
+ */
+function encrypt(plaintext, key) {
+  const iv = crypto.randomBytes(12); // 96-bit nonce
+  const cipher = crypto.createCipheriv("aes-256-gcm", key, iv);
+  const ct = Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()]);
+  const tag = cipher.getAuthTag();
+  return {
+    iv: iv.toString("base64"),
+    ct: ct.toString("base64"),
+    tag: tag.toString("base64"),
+  };
+}
+
+/**
+ * Decrypt ciphertext using AES-256-GCM.
+ * @param {{ iv: string, ct: string, tag: string }} encrypted - base64-encoded components
+ * @param {Buffer} key - 32-byte AES-256 key
+ * @returns {string} UTF-8 plaintext
+ * @throws {Error} if authentication tag is invalid or key is wrong
+ */
+function decrypt({ iv, ct, tag }, key) {
+  const decipher = crypto.createDecipheriv("aes-256-gcm", key, Buffer.from(iv, "base64"));
+  decipher.setAuthTag(Buffer.from(tag, "base64"));
+  // update() returns Buffer, must explicitly convert to utf8 to avoid corruption with non-ASCII
+  return decipher.update(Buffer.from(ct, "base64")).toString("utf8") + decipher.final("utf8");
+}
+
+/**
+ * Compute human-verifiable fingerprint from X25519 shared secret.
+ * Both endpoints independently derive the same fingerprint —
+ * matching values prove no MITM substituted keys.
+ * @param {Buffer} sharedSecret - 32-byte X25519 shared secret
+ * @returns {string} fingerprint as "xx:xx:xx:xx:xx:xx" (6 hex bytes)
+ */
+function computeFingerprint(sharedSecret) {
+  const hash = crypto.createHash("sha256")
+    .update("sema-fp")
+    .update(sharedSecret)
+    .digest();
+  return Array.from(hash.subarray(0, 6))
+    .map(b => b.toString(16).padStart(2, "0"))
+    .join(":");
+}
+
+module.exports = {
+  generateKeyPair,
+  exportPublicKey,
+  exportPrivateKey,
+  importPublicKey,
+  importPrivateKey,
+  deriveSharedSecret,
+  deriveAesKey,
+  encrypt,
+  decrypt,
+  computeFingerprint,
+};

package/experiments/spike-shell-stream/shared/crypto.test.js

@@ -0,0 +1,350 @@
+const { describe, it } = require("node:test");
+const assert = require("node:assert/strict");
+const {
+  generateKeyPair,
+  exportPublicKey,
+  importPublicKey,
+  deriveSharedSecret,
+  deriveAesKey,
+  encrypt,
+  decrypt,
+  computeFingerprint,
+} = require("./crypto");
+
+describe("generateKeyPair", () => {
+  it("generates valid X25519 key pair", () => {
+    const keyPair = generateKeyPair();
+    assert.ok(keyPair.privateKey, "privateKey should exist");
+    assert.ok(keyPair.publicKey, "publicKey should exist");
+    assert.strictEqual(keyPair.privateKey.asymmetricKeyType, "x25519");
+    assert.strictEqual(keyPair.publicKey.asymmetricKeyType, "x25519");
+  });
+
+  it("generates unique key pairs", () => {
+    const kp1 = generateKeyPair();
+    const kp2 = generateKeyPair();
+    const pub1 = exportPublicKey(kp1.publicKey);
+    const pub2 = exportPublicKey(kp2.publicKey);
+    assert.notStrictEqual(pub1, pub2, "different key pairs should have different public keys");
+  });
+});
+
+describe("exportPublicKey / importPublicKey", () => {
+  it("roundtrip preserves public key", () => {
+    const keyPair = generateKeyPair();
+    const exported = exportPublicKey(keyPair.publicKey);
+    assert.strictEqual(typeof exported, "string");
+    assert.ok(exported.length > 0, "exported key should not be empty");
+
+    const imported = importPublicKey(exported);
+    assert.strictEqual(imported.asymmetricKeyType, "x25519");
+
+    // Verify by re-exporting
+    const reexported = exportPublicKey(imported);
+    assert.strictEqual(reexported, exported, "re-exported key should match original");
+  });
+
+  it("exported key is valid base64", () => {
+    const keyPair = generateKeyPair();
+    const exported = exportPublicKey(keyPair.publicKey);
+    // Should not throw
+    Buffer.from(exported, "base64");
+  });
+});
+
+describe("deriveSharedSecret", () => {
+  it("both parties derive identical shared secret", () => {
+    const alice = generateKeyPair();
+    const bob = generateKeyPair();
+
+    const aliceSecret = deriveSharedSecret(alice.privateKey, bob.publicKey);
+    const bobSecret = deriveSharedSecret(bob.privateKey, alice.publicKey);
+
+    assert.ok(Buffer.isBuffer(aliceSecret), "shared secret should be Buffer");
+    assert.strictEqual(aliceSecret.length, 32, "shared secret should be 32 bytes");
+    assert.deepStrictEqual(aliceSecret, bobSecret, "both parties should derive same secret");
+  });
+
+  it("shared secret differs for different key pairs", () => {
+    const alice = generateKeyPair();
+    const bob = generateKeyPair();
+    const charlie = generateKeyPair();
+
+    const abSecret = deriveSharedSecret(alice.privateKey, bob.publicKey);
+    const acSecret = deriveSharedSecret(alice.privateKey, charlie.publicKey);
+
+    assert.notDeepStrictEqual(abSecret, acSecret, "different peers should yield different secrets");
+  });
+});
+
+describe("deriveAesKey", () => {
+  it("derives 32-byte AES key from shared secret", () => {
+    const alice = generateKeyPair();
+    const bob = generateKeyPair();
+    const sharedSecret = deriveSharedSecret(alice.privateKey, bob.publicKey);
+
+    const aesKey = deriveAesKey(sharedSecret);
+    assert.ok(Buffer.isBuffer(aesKey), "AES key should be Buffer");
+    assert.strictEqual(aesKey.length, 32, "AES key should be 32 bytes (256 bits)");
+  });
+
+  it("same shared secret produces same AES key", () => {
+    const alice = generateKeyPair();
+    const bob = generateKeyPair();
+    const secret = deriveSharedSecret(alice.privateKey, bob.publicKey);
+
+    const key1 = deriveAesKey(secret);
+    const key2 = deriveAesKey(secret);
+
+    assert.deepStrictEqual(key1, key2, "same secret should produce same key");
+  });
+
+  it("different salt produces different AES key", () => {
+    const alice = generateKeyPair();
+    const bob = generateKeyPair();
+    const secret = deriveSharedSecret(alice.privateKey, bob.publicKey);
+
+    const key1 = deriveAesKey(secret);
+    const key2 = deriveAesKey(secret, Buffer.from("different-salt", "utf8"));
+
+    assert.notDeepStrictEqual(key1, key2, "different salt should produce different key");
+  });
+});
+
+describe("encrypt / decrypt", () => {
+  it("roundtrip preserves plaintext", () => {
+    const alice = generateKeyPair();
+    const bob = generateKeyPair();
+    const secret = deriveSharedSecret(alice.privateKey, bob.publicKey);
+    const key = deriveAesKey(secret);
+
+    const plaintext = "Hello, E2E encryption!";
+    const encrypted = encrypt(plaintext, key);
+
+    assert.strictEqual(typeof encrypted.iv, "string");
+    assert.strictEqual(typeof encrypted.ct, "string");
+    assert.strictEqual(typeof encrypted.tag, "string");
+
+    const decrypted = decrypt(encrypted, key);
+    assert.strictEqual(decrypted, plaintext);
+  });
+
+  it("handles non-ASCII characters", () => {
+    const keyPair = generateKeyPair();
+    const secret = deriveSharedSecret(keyPair.privateKey, keyPair.publicKey);
+    const key = deriveAesKey(secret);
+
+    const plaintext = "你好世界 🌍 Привет мир";
+    const encrypted = encrypt(plaintext, key);
+    const decrypted = decrypt(encrypted, key);
+
+    assert.strictEqual(decrypted, plaintext);
+  });
+
+  it("handles empty string", () => {
+    const keyPair = generateKeyPair();
+    const secret = deriveSharedSecret(keyPair.privateKey, keyPair.publicKey);
+    const key = deriveAesKey(secret);
+
+    const plaintext = "";
+    const encrypted = encrypt(plaintext, key);
+    const decrypted = decrypt(encrypted, key);
+
+    assert.strictEqual(decrypted, plaintext);
+  });
+
+  it("handles large payload", () => {
+    const keyPair = generateKeyPair();
+    const secret = deriveSharedSecret(keyPair.privateKey, keyPair.publicKey);
+    const key = deriveAesKey(secret);
+
+    const plaintext = "x".repeat(10000);
+    const encrypted = encrypt(plaintext, key);
+    const decrypted = decrypt(encrypted, key);
+
+    assert.strictEqual(decrypted, plaintext);
+  });
+
+  it("each encryption produces different ciphertext (random IV)", () => {
+    const keyPair = generateKeyPair();
+    const secret = deriveSharedSecret(keyPair.privateKey, keyPair.publicKey);
+    const key = deriveAesKey(secret);
+
+    const plaintext = "same message";
+    const enc1 = encrypt(plaintext, key);
+    const enc2 = encrypt(plaintext, key);
+
+    assert.notStrictEqual(enc1.iv, enc2.iv, "IVs should differ");
+    assert.notStrictEqual(enc1.ct, enc2.ct, "ciphertexts should differ");
+  });
+
+  it("decryption fails with wrong key", () => {
+    const alice = generateKeyPair();
+    const bob = generateKeyPair();
+    const charlie = generateKeyPair();
+
+    const abSecret = deriveSharedSecret(alice.privateKey, bob.publicKey);
+    const acSecret = deriveSharedSecret(alice.privateKey, charlie.publicKey);
+
+    const keyAB = deriveAesKey(abSecret);
+    const keyAC = deriveAesKey(acSecret);
+
+    const encrypted = encrypt("secret message", keyAB);
+
+    assert.throws(
+      () => decrypt(encrypted, keyAC),
+      /Unsupported state or unable to/,
+      "decryption with wrong key should fail"
+    );
+  });
+
+  it("decryption fails with tampered ciphertext", () => {
+    const keyPair = generateKeyPair();
+    const secret = deriveSharedSecret(keyPair.privateKey, keyPair.publicKey);
+    const key = deriveAesKey(secret);
+
+    const encrypted = encrypt("test", key);
+    // Tamper with ciphertext
+    const tampered = {
+      ...encrypted,
+      ct: encrypted.ct.slice(0, -2) + "xx",
+    };
+
+    assert.throws(
+      () => decrypt(tampered, key),
+      /Unsupported state or unable to/,
+      "decryption with tampered ciphertext should fail"
+    );
+  });
+
+  it("decryption fails with tampered auth tag", () => {
+    const keyPair = generateKeyPair();
+    const secret = deriveSharedSecret(keyPair.privateKey, keyPair.publicKey);
+    const key = deriveAesKey(secret);
+
+    const encrypted = encrypt("test", key);
+    // Tamper with tag
+    const tampered = {
+      ...encrypted,
+      tag: "AAAAAAAAAAAAAAAAAAAAAA==", // fake tag
+    };
+
+    assert.throws(
+      () => decrypt(tampered, key),
+      /Unsupported state or unable to/,
+      "decryption with tampered tag should fail"
+    );
+  });
+});
+
+describe("full E2E key exchange simulation", () => {
+  it("simulates Mac ↔ Mobile key exchange and encrypted communication", () => {
+    // Mac generates keypair
+    const macKeyPair = generateKeyPair();
+    const macPublicKeyExport = exportPublicKey(macKeyPair.publicKey);
+
+    // Mobile receives macPublicKey (via pairing channel)
+    const macPublicKeyOnMobile = importPublicKey(macPublicKeyExport);
+
+    // Mobile generates keypair
+    const mobileKeyPair = generateKeyPair();
+    const mobilePublicKeyExport = exportPublicKey(mobileKeyPair.publicKey);
+
+    // Mac receives mobilePublicKey (via WebSocket)
+    const mobilePublicKeyOnMac = importPublicKey(mobilePublicKeyExport);
+
+    // Both derive shared secret
+    const macSharedSecret = deriveSharedSecret(macKeyPair.privateKey, mobilePublicKeyOnMac);
+    const mobileSharedSecret = deriveSharedSecret(mobileKeyPair.privateKey, macPublicKeyOnMobile);
+
+    assert.deepStrictEqual(macSharedSecret, mobileSharedSecret, "shared secrets must match");
+
+    // Both derive AES key
+    const macAesKey = deriveAesKey(macSharedSecret);
+    const mobileAesKey = deriveAesKey(mobileSharedSecret);
+
+    assert.deepStrictEqual(macAesKey, mobileAesKey, "AES keys must match");
+
+    // Mac encrypts output → Mobile decrypts
+    const terminalOutput = "$ ls -la\ntotal 42\ndrwxr-xr-x  5 user staff 160 Jan 1 00:00 .";
+    const encryptedOutput = encrypt(terminalOutput, macAesKey);
+    const decryptedOutput = decrypt(encryptedOutput, mobileAesKey);
+
+    assert.strictEqual(decryptedOutput, terminalOutput);
+
+    // Mobile encrypts input → Mac decrypts
+    const userInput = "cd ~/projects";
+    const encryptedInput = encrypt(userInput, mobileAesKey);
+    const decryptedInput = decrypt(encryptedInput, macAesKey);
+
+    assert.strictEqual(decryptedInput, userInput);
+  });
+});
+
+describe("computeFingerprint", () => {
+  it("returns correct format: xx:xx:xx:xx:xx:xx (17 chars, lowercase hex)", () => {
+    const kp1 = generateKeyPair();
+    const kp2 = generateKeyPair();
+    const secret = deriveSharedSecret(kp1.privateKey, kp2.publicKey);
+    const fp = computeFingerprint(secret);
+    assert.strictEqual(fp.length, 17);
+    assert.match(fp, /^[0-9a-f]{2}(:[0-9a-f]{2}){5}$/);
+  });
+
+  it("is deterministic — same input produces same output", () => {
+    const secret = Buffer.alloc(32, 0xab);
+    const fp1 = computeFingerprint(secret);
+    const fp2 = computeFingerprint(secret);
+    assert.strictEqual(fp1, fp2);
+  });
+
+  it("same shared secret from both sides produces same fingerprint", () => {
+    const mac = generateKeyPair();
+    const mobile = generateKeyPair();
+    const macSecret = deriveSharedSecret(mac.privateKey, mobile.publicKey);
+    const mobileSecret = deriveSharedSecret(mobile.privateKey, mac.publicKey);
+    assert.strictEqual(computeFingerprint(macSecret), computeFingerprint(mobileSecret));
+  });
+
+  it("different shared secrets produce different fingerprints", () => {
+    const kp1 = generateKeyPair();
+    const kp2 = generateKeyPair();
+    const kp3 = generateKeyPair();
+    const secret1 = deriveSharedSecret(kp1.privateKey, kp2.publicKey);
+    const secret2 = deriveSharedSecret(kp1.privateKey, kp3.publicKey);
+    assert.notStrictEqual(computeFingerprint(secret1), computeFingerprint(secret2));
+  });
+
+  it("cross-platform equivalence — known input produces expected output", () => {
+    // Fixed 32-byte input for reproducible cross-platform test
+    const input = Buffer.from("0123456789abcdef0123456789abcdef");
+    const fp = computeFingerprint(input);
+
+    // Verify by computing expected manually with crypto module
+    const crypto = require("node:crypto");
+    const expected = crypto.createHash("sha256")
+      .update("sema-fp")
+      .update(input)
+      .digest()
+      .subarray(0, 6);
+    const expectedStr = Array.from(expected)
+      .map(b => b.toString(16).padStart(2, "0"))
+      .join(":");
+
+    assert.strictEqual(fp, expectedStr);
+  });
+
+  it("uses domain separator different from HKDF", () => {
+    // The fingerprint hash uses "sema-fp" prefix,
+    // HKDF uses "sema-e2e" salt. They must produce different outputs
+    // even with the same shared secret.
+    const secret = Buffer.alloc(32, 0x42);
+    const fp = computeFingerprint(secret);
+    const aesKey = deriveAesKey(secret);
+
+    // fp and aesKey hex should be different (they use different derivation paths)
+    const fpHex = fp.replace(/:/g, "");
+    const aesHex = aesKey.toString("hex").slice(0, 12);
+    assert.notStrictEqual(fpHex, aesHex);
+  });
+});

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "sema-cli",
+  "version": "0.1.0",
+  "description": "Sema — the signal between you and your agents. A mobile collaboration layer for AI coding agents.",
+  "bin": {
+    "sema": "experiments/spike-shell-stream/bin/sema.js"
+  },
+  "files": [
+    "experiments/spike-shell-stream/bin/",
+    "experiments/spike-shell-stream/relay-server/",
+    "experiments/spike-shell-stream/mac-agent/",
+    "experiments/spike-shell-stream/mobile-web/",
+    "experiments/spike-shell-stream/shared/"
+  ],
+  "scripts": {
+    "start": "node experiments/spike-shell-stream/bin/start.js",
+    "spike:relay": "node experiments/spike-shell-stream/relay-server/server.js",
+    "spike:agent": "node experiments/spike-shell-stream/mac-agent/agent.js",
+    "spike:agent:cli": "CLI_COMMAND=zsh node experiments/spike-shell-stream/mac-agent/agent.js",
+    "spike:test-client": "node experiments/spike-shell-stream/test-client.js",
+    "spike:clean": "tmux kill-server 2>/dev/null; echo 'tmux sessions cleared'",
+    "test": "node --test experiments/spike-shell-stream/shared/crypto.test.js experiments/spike-shell-stream/mac-agent/analyzer.test.js"
+  },
+  "dependencies": {
+    "node-pty-prebuilt-multiarch": "^0.10.1-pre.5",
+    "qrcode-terminal": "^0.12.0"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "os": [
+    "darwin"
+  ],
+  "keywords": [
+    "ai",
+    "coding",
+    "agent",
+    "mobile",
+    "claude-code",
+    "remote",
+    "terminal"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/PikuluSama/sema.git"
+  },
+  "homepage": "https://github.com/PikuluSama/sema#readme",
+  "bugs": {
+    "url": "https://github.com/PikuluSama/sema/issues"
+  }
+}