@aithos/sdk 0.1.0-alpha.5 → 0.1.0-alpha.51

package/dist/test/signup-bootstrap.test.js

@@ -0,0 +1,311 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2026 Mathieu Colla
+// Tests for the Ethos bootstrap step inside AithosAuth.signUp().
+//
+// The contract:
+//   1. POST /auth/register → creates the auth user (auth.aithos.be).
+//   2. POST /mcp/primitives/write with method=aithos.publish_identity →
+//      provisions the user's Ethos on api.aithos.be.
+//   3. Hydrate local state ONLY after both steps succeed.
+//
+// Failure modes:
+//   - register fails  → throw, no publish_identity attempted, no hydrate.
+//   - publish_identity rejected (JSON-RPC error) → throw immediately,
+//     no retry, no hydrate.
+//   - publish_identity 5xx / network error → 2 retries with backoff,
+//     then throw `ethos_bootstrap_failed` if all fail.
+//
+// We mock fetch end-to-end so the tests run offline. The protocol-client
+// crypto runs for real — we want to assert that the envelope shape coming
+// out of the SDK matches what api.aithos.be will accept.
+import { strict as assert } from "node:assert";
+import { describe, it } from "node:test";
+import { AithosAuth, AithosSDKError, memoryKeyStore, noopStore, } from "../src/index.js";
+function makeMockFetch(handlers) {
+    const calls = [];
+    const fetchImpl = (async (input, init) => {
+        const url = String(input);
+        const method = init?.method ?? "GET";
+        const bodyText = typeof init?.body === "string"
+            ? init.body
+            : init?.body == null
+                ? null
+                : String(init.body);
+        const body = bodyText ? JSON.parse(bodyText) : null;
+        const call = { url, method, body };
+        calls.push(call);
+        for (const h of handlers) {
+            if (!url.includes(h.url))
+                continue;
+            if (h.method && h.method !== method)
+                continue;
+            if (h.remaining !== undefined && h.remaining <= 0)
+                continue;
+            if (h.remaining !== undefined)
+                h.remaining--;
+            const out = await h.respond(call);
+            const status = out.status ?? 200;
+            return new Response(JSON.stringify(out.json), {
+                status,
+                headers: { "content-type": "application/json" },
+            });
+        }
+        throw new Error(`unhandled fetch: ${method} ${url}`);
+    });
+    return { fetch: fetchImpl, calls };
+}
+function fakeRegisterOk() {
+    return {
+        json: {
+            session: "jwt-token-here",
+            exp: Math.floor(Date.now() / 1000) + 3600,
+        },
+    };
+}
+function fakePublishIdentityOk() {
+    return {
+        json: {
+            jsonrpc: "2.0",
+            id: "publish_identity",
+            result: { ok: true, did_document_url: "https://cdn.aithos.be/ethos/zABC/did.json" },
+        },
+    };
+}
+function makeAuth(fetchImpl) {
+    return new AithosAuth({
+        authBaseUrl: "https://auth.test",
+        apiBaseUrl: "https://api.test",
+        fetch: fetchImpl,
+        sessionStore: noopStore(),
+        keyStore: memoryKeyStore(),
+    });
+}
+const validInput = {
+    email: "alice@test.example",
+    password: "correct horse battery staple",
+    handle: "alice",
+};
+/* -------------------------------------------------------------------------- */
+/*  Happy path                                                                */
+/* -------------------------------------------------------------------------- */
+describe("AithosAuth.signUp — Ethos bootstrap", () => {
+    it("calls /auth/register THEN /mcp/primitives/write with publish_identity", async () => {
+        const { fetch: f, calls } = makeMockFetch([
+            { url: "/auth/register", method: "POST", respond: fakeRegisterOk },
+            {
+                url: "/mcp/primitives/write",
+                method: "POST",
+                respond: fakePublishIdentityOk,
+            },
+        ]);
+        const auth = makeAuth(f);
+        const r = await auth.signUp(validInput);
+        assert.equal(calls.length, 2, "should make exactly 2 calls");
+        assert.match(calls[0].url, /\/auth\/register$/);
+        assert.match(calls[1].url, /\/mcp\/primitives\/write$/);
+        assert.ok(r.session.session === "jwt-token-here");
+        assert.ok(auth.canSignAsOwner(), "must be hydrated as owner");
+    });
+    it("envelope is JSON-RPC publish_identity, signed by #root, with valid params", async () => {
+        let publishBody = null;
+        const { fetch: f } = makeMockFetch([
+            { url: "/auth/register", method: "POST", respond: fakeRegisterOk },
+            {
+                url: "/mcp/primitives/write",
+                method: "POST",
+                respond: (call) => {
+                    publishBody = call.body;
+                    return fakePublishIdentityOk();
+                },
+            },
+        ]);
+        await makeAuth(f).signUp(validInput);
+        // JSON-RPC envelope shape
+        assert.equal(publishBody.jsonrpc, "2.0");
+        assert.equal(publishBody.method, "aithos.publish_identity");
+        // params include the inline _envelope and the publish_identity payload
+        const params = publishBody.params;
+        assert.equal(typeof params.handle, "string");
+        assert.equal(params.handle, "alice");
+        assert.equal(typeof params.display_name, "string");
+        assert.ok(params.did_document, "did_document must be present");
+        assert.ok(params._envelope, "_envelope must be present");
+        // envelope is signed by #root
+        const env = params._envelope;
+        assert.equal(env["aithos-envelope"], "0.1.0");
+        assert.match(env.iss, /^did:aithos:/);
+        assert.equal(env.method, "aithos.publish_identity");
+        assert.equal(env.aud, "https://api.test/mcp/primitives/write");
+        assert.equal(env.proof.type, "Ed25519Signature2020");
+        assert.match(env.proof.verificationMethod, /#root$/);
+        assert.equal(typeof env.proof.proofValue, "string");
+        assert.ok(env.proof.proofValue.length > 0);
+    });
+    it("does NOT hydrate state when /auth/register fails", async () => {
+        const { fetch: f, calls } = makeMockFetch([
+            {
+                url: "/auth/register",
+                method: "POST",
+                respond: () => ({
+                    status: 409,
+                    json: { error: "email_taken" },
+                }),
+            },
+        ]);
+        const auth = makeAuth(f);
+        await assert.rejects(() => auth.signUp(validInput), AithosSDKError);
+        assert.equal(calls.length, 1, "publish_identity must NOT be called");
+        assert.equal(auth.canSignAsOwner(), false);
+    });
+    it("does NOT hydrate state when publish_identity returns a JSON-RPC error", async () => {
+        const { fetch: f, calls } = makeMockFetch([
+            { url: "/auth/register", method: "POST", respond: fakeRegisterOk },
+            {
+                url: "/mcp/primitives/write",
+                method: "POST",
+                respond: () => ({
+                    json: {
+                        jsonrpc: "2.0",
+                        id: "publish_identity",
+                        error: { code: -32600, message: "invalid envelope signature" },
+                    },
+                }),
+            },
+        ]);
+        const auth = makeAuth(f);
+        await assert.rejects(() => auth.signUp(validInput), (e) => e instanceof AithosSDKError && e.code === "ethos_bootstrap_failed");
+        // No retry on JSON-RPC error: 1 register + 1 publish.
+        assert.equal(calls.length, 2);
+        assert.equal(auth.canSignAsOwner(), false);
+    });
+    it("retries publish_identity on 5xx, then succeeds", async () => {
+        let publishCalls = 0;
+        const { fetch: f } = makeMockFetch([
+            { url: "/auth/register", method: "POST", respond: fakeRegisterOk },
+            {
+                url: "/mcp/primitives/write",
+                method: "POST",
+                respond: () => {
+                    publishCalls++;
+                    if (publishCalls < 2) {
+                        return { status: 503, json: { error: "transient" } };
+                    }
+                    return fakePublishIdentityOk();
+                },
+            },
+        ]);
+        const auth = makeAuth(f);
+        await auth.signUp(validInput);
+        assert.equal(publishCalls, 2);
+        assert.ok(auth.canSignAsOwner());
+    });
+    it("throws ethos_bootstrap_failed after all retries fail with 5xx", async () => {
+        let publishCalls = 0;
+        const { fetch: f } = makeMockFetch([
+            { url: "/auth/register", method: "POST", respond: fakeRegisterOk },
+            {
+                url: "/mcp/primitives/write",
+                method: "POST",
+                respond: () => {
+                    publishCalls++;
+                    return { status: 503, json: { error: "transient" } };
+                },
+            },
+        ]);
+        const auth = makeAuth(f);
+        await assert.rejects(() => auth.signUp(validInput), (e) => e instanceof AithosSDKError && e.code === "ethos_bootstrap_failed");
+        // 3 attempts total (initial + 2 retries).
+        assert.equal(publishCalls, 3);
+        assert.equal(auth.canSignAsOwner(), false);
+    });
+    /* ------------------------------------------------------------------------ */
+    /*  alpha.36 — defense-in-depth for legacy backends without semantic-equal  */
+    /* ------------------------------------------------------------------------ */
+    it("treats -32022 'different did.json already published' as a no-op success", async () => {
+        // This is the regression introduced in alpha.33: republishing the same
+        // identity returns -32022 because `signedDidDocument()` regenerates
+        // `aithos.created_at` on every call. For an honest signer, this is
+        // semantically a no-op — the Ethos is published, crypto material matches.
+        // The SDK swallows this specific case so chatty publish_identity callers
+        // (signInCustodial, verifyEmail) don't break on every subsequent sign-in.
+        const { fetch: f, calls } = makeMockFetch([
+            { url: "/auth/register", method: "POST", respond: fakeRegisterOk },
+            {
+                url: "/mcp/primitives/write",
+                method: "POST",
+                respond: () => ({
+                    json: {
+                        jsonrpc: "2.0",
+                        id: "publish_identity",
+                        error: {
+                            code: -32022,
+                            message: "different did.json already published for this DID",
+                            data: { existing_doc_url: "https://cdn.aithos.be/did.json" },
+                        },
+                    },
+                }),
+            },
+        ]);
+        const auth = makeAuth(f);
+        // Must succeed, not throw — the republish-conflict is masked.
+        await auth.signUp(validInput);
+        // Hydrate worked: owner is loaded.
+        assert.equal(auth.canSignAsOwner(), true);
+        // No retry on -32022 (deterministic) — exactly 1 publish call.
+        assert.equal(calls.filter((c) => c.url.includes("/mcp/primitives/write")).length, 1, "publish_identity must not retry on -32022");
+    });
+    it("still throws ethos_bootstrap_failed on -32022 with a DIFFERENT message", async () => {
+        // The shim is narrow: it ONLY swallows the specific
+        // "different did.json already published" message. Other -32022 cases
+        // (server might use the same code for different semantics) must still
+        // bubble up as ethos_bootstrap_failed.
+        const { fetch: f } = makeMockFetch([
+            { url: "/auth/register", method: "POST", respond: fakeRegisterOk },
+            {
+                url: "/mcp/primitives/write",
+                method: "POST",
+                respond: () => ({
+                    json: {
+                        jsonrpc: "2.0",
+                        id: "publish_identity",
+                        error: {
+                            code: -32022,
+                            message: "subject identity is tombstoned",
+                        },
+                    },
+                }),
+            },
+        ]);
+        const auth = makeAuth(f);
+        await assert.rejects(() => auth.signUp(validInput), (e) => e instanceof AithosSDKError &&
+            e.code === "ethos_bootstrap_failed" &&
+            /tombstoned/i.test(e.message));
+        assert.equal(auth.canSignAsOwner(), false);
+    });
+    it("still throws ethos_bootstrap_failed on the conflict message under a different code", async () => {
+        // Conversely, an error matching the message but with a code OTHER than
+        // -32022 is not swallowed — we anchor on both (code, message) to keep
+        // the shim narrow.
+        const { fetch: f } = makeMockFetch([
+            { url: "/auth/register", method: "POST", respond: fakeRegisterOk },
+            {
+                url: "/mcp/primitives/write",
+                method: "POST",
+                respond: () => ({
+                    json: {
+                        jsonrpc: "2.0",
+                        id: "publish_identity",
+                        error: {
+                            code: -32000,
+                            message: "different did.json already published for this DID",
+                        },
+                    },
+                }),
+            },
+        ]);
+        const auth = makeAuth(f);
+        await assert.rejects(() => auth.signUp(validInput), (e) => e instanceof AithosSDKError && e.code === "ethos_bootstrap_failed");
+        assert.equal(auth.canSignAsOwner(), false);
+    });
+});
+//# sourceMappingURL=signup-bootstrap.test.js.map

package/dist/test/transcribe-invoke.test.d.ts

@@ -0,0 +1,2 @@
+import "fake-indexeddb/auto";
+//# sourceMappingURL=transcribe-invoke.test.d.ts.map

package/dist/test/transcribe-invoke.test.js

@@ -0,0 +1,204 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2026 Mathieu Colla
+// Tests for the high-level invokeTranscribe flow (prepare -> upload -> start
+// -> poll) and the framework-agnostic resilience helpers (local pending
+// tracker + IndexedDB draft store). fake-indexeddb/auto installs an
+// in-memory IndexedDB for the draft tests.
+import "fake-indexeddb/auto";
+import { strict as assert } from "node:assert";
+import { describe, it } from "node:test";
+import { createBrowserIdentity } from "@aithos/protocol-client";
+import { AithosAuth, AithosSDK, LocalPendingTranscribeTracker, TranscribeDraftStore, memoryKeyStore, noopStore, } from "../src/index.js";
+import { serializeRecoveryFile } from "../src/internal/recovery-file.js";
+const APP_DID = "did:aithos:app:test";
+const UPLOAD_URL = "https://s3.example.test/upload?sig=abc";
+async function makeSdk(fetchImpl) {
+    const id = createBrowserIdentity("test-handle", "Test User");
+    const auth = new AithosAuth({
+        authBaseUrl: "https://auth.test",
+        fetch: (() => {
+            throw new Error("auth not used");
+        }),
+        sessionStore: noopStore(),
+        keyStore: memoryKeyStore(),
+    });
+    const { text } = serializeRecoveryFile(id);
+    await auth.signInWithRecovery({ file: text });
+    return new AithosSDK({
+        auth,
+        appDid: APP_DID,
+        endpoints: { compute: "https://compute.example.test" },
+        fetch: fetchImpl,
+    });
+}
+function jsonRpc(result) {
+    return new Response(JSON.stringify({ result }), {
+        status: 200,
+        headers: { "content-type": "application/json" },
+    });
+}
+describe("compute.invokeTranscribe — full flow", () => {
+    it("prepares, uploads to S3, starts, polls and returns the transcript", async () => {
+        const calls = [];
+        let putBytes = 0;
+        let statusPolls = 0;
+        const fetchImpl = async (input, init) => {
+            const url = typeof input === "string" ? input : input.toString();
+            if (init?.method === "PUT" && url.startsWith("https://s3.example.test/")) {
+                // S3 upload.
+                calls.push("s3-put");
+                putBytes = init.body.size;
+                return new Response("", { status: 200 });
+            }
+            const method = JSON.parse(init?.body).method;
+            calls.push(method);
+            if (method === "aithos.compute_transcribe_prepare") {
+                return jsonRpc({
+                    job_id: "tj_FLOW",
+                    upload_url: UPLOAD_URL,
+                    s3_object_key: "uploads/2026/05/tj_FLOW.webm",
+                    expires_at: 1717000000,
+                });
+            }
+            if (method === "aithos.compute_transcribe_start") {
+                return jsonRpc({
+                    job_id: "tj_FLOW",
+                    status: "running",
+                    estimated_credits: 60,
+                    walletBalance: 49_940,
+                    fundedBy: "purchase",
+                });
+            }
+            if (method === "aithos.compute_transcribe_status") {
+                statusPolls += 1;
+                if (statusPolls < 2) {
+                    return jsonRpc({ job_id: "tj_FLOW", status: "running", elapsed_sec: 1 });
+                }
+                return jsonRpc({
+                    job_id: "tj_FLOW",
+                    status: "completed",
+                    text: "Bonjour le monde",
+                    segments: [{ start_sec: 0, end_sec: 1.4, text: "Bonjour le monde" }],
+                    words: [{ start_sec: 0, end_sec: 0.4, content: "Bonjour", confidence: 0.99 }],
+                    duration_sec_actual: 30,
+                    language_code: "fr-FR",
+                    creditsCharged: 60,
+                    walletBalance: 49_940,
+                    auditId: "audit_flow",
+                    fundedBy: "purchase",
+                });
+            }
+            throw new Error(`unexpected method ${method}`);
+        };
+        const sdk = await makeSdk(fetchImpl);
+        const phases = [];
+        const audio = new Blob([new Uint8Array(2048)], { type: "audio/webm" });
+        const result = await sdk.compute.invokeTranscribe({
+            audio,
+            durationSecOverride: 30,
+            pollIntervalMs: 1,
+            onProgress: (s) => phases.push(s.phase),
+        });
+        assert.equal(result.text, "Bonjour le monde");
+        assert.equal(result.durationSec, 30);
+        assert.equal(result.creditsCharged, 60);
+        assert.equal(result.jobId, "tj_FLOW");
+        assert.equal(result.fundedBy, "purchase");
+        assert.equal(result.segments.length, 1);
+        // The flow visited every step in order.
+        assert.deepEqual(calls, [
+            "aithos.compute_transcribe_prepare",
+            "s3-put",
+            "aithos.compute_transcribe_start",
+            "aithos.compute_transcribe_status",
+            "aithos.compute_transcribe_status",
+        ]);
+        assert.equal(putBytes, 2048);
+        assert.ok(phases.includes("queued"));
+        assert.ok(phases.includes("uploading"));
+        assert.ok(phases.includes("starting"));
+        assert.ok(phases.includes("completed"));
+        // Job cleared from the local pending tracker on success.
+        assert.equal(sdk.compute.listLocalPendingTranscribes().length, 0);
+    });
+    it("throws an AithosSDKError when the job fails, leaving the job flagged failed", async () => {
+        const fetchImpl = async (input, init) => {
+            const url = typeof input === "string" ? input : input.toString();
+            if (init?.method === "PUT")
+                return new Response("", { status: 200 });
+            const method = JSON.parse(init?.body).method;
+            if (method === "aithos.compute_transcribe_prepare") {
+                return jsonRpc({ job_id: "tj_F", upload_url: UPLOAD_URL, s3_object_key: "k", expires_at: 1 });
+            }
+            if (method === "aithos.compute_transcribe_start") {
+                return jsonRpc({ job_id: "tj_F", status: "running", estimated_credits: 60, walletBalance: 1 });
+            }
+            return jsonRpc({
+                job_id: "tj_F",
+                status: "failed",
+                error: { code: "transcribe_provider_error", message: "bad audio" },
+            });
+        };
+        const sdk = await makeSdk(fetchImpl);
+        const audio = new Blob([new Uint8Array(10)], { type: "audio/webm" });
+        await assert.rejects(() => sdk.compute.invokeTranscribe({ audio, durationSecOverride: 30, pollIntervalMs: 1 }), (e) => {
+            assert.ok(e instanceof Error);
+            assert.match(e.message, /bad audio/);
+            return true;
+        });
+        const pending = sdk.compute.listLocalPendingTranscribes();
+        assert.equal(pending.find((p) => p.jobId === "tj_F")?.status, "failed");
+    });
+});
+describe("LocalPendingTranscribeTracker (vanilla, framework-agnostic)", () => {
+    it("upserts, lists, removes and notifies subscribers", () => {
+        const t = new LocalPendingTranscribeTracker();
+        t.clear();
+        let notifications = 0;
+        const unsub = t.subscribe(() => {
+            notifications += 1;
+        });
+        t.upsert("tj_1", "uploading", { model: "transcribe:aws-fr-standard" });
+        assert.equal(t.list().length, 1);
+        assert.equal(t.list()[0]?.status, "uploading");
+        t.upsert("tj_1", "running");
+        assert.equal(t.list().length, 1, "same job id updates in place");
+        assert.equal(t.list()[0]?.status, "running");
+        t.upsert("tj_2", "running");
+        assert.equal(t.list().length, 2);
+        t.remove("tj_1");
+        assert.equal(t.list().length, 1);
+        assert.equal(t.list()[0]?.jobId, "tj_2");
+        assert.ok(notifications >= 4, "subscriber fired on each mutation");
+        unsub();
+        const before = notifications;
+        t.upsert("tj_3", "running");
+        assert.equal(notifications, before, "no notification after unsubscribe");
+    });
+    it("getSnapshot returns a stable reference between mutations", () => {
+        const t = new LocalPendingTranscribeTracker();
+        t.clear();
+        const a = t.getSnapshot();
+        const b = t.getSnapshot();
+        assert.equal(a, b);
+        t.upsert("tj_x", "running");
+        assert.notEqual(t.getSnapshot(), a, "new reference after a mutation");
+    });
+});
+describe("TranscribeDraftStore (IndexedDB via fake-indexeddb)", () => {
+    it("saves, lists, gets and deletes a draft", async () => {
+        const store = new TranscribeDraftStore();
+        const blob = new Blob([new Uint8Array(64)], { type: "audio/webm" });
+        const { draftId } = await store.save(blob, { title: "séance 1" });
+        assert.ok(draftId.startsWith("draft_"));
+        const list = await store.list();
+        assert.ok(list.some((d) => d.draftId === draftId));
+        const got = await store.get(draftId);
+        assert.equal(got?.metadata.title, "séance 1");
+        assert.equal(got?.metadata.contentType, "audio/webm");
+        assert.equal(got?.blob.size, 64);
+        await store.delete(draftId);
+        assert.equal(await store.get(draftId), null);
+    });
+});
+//# sourceMappingURL=transcribe-invoke.test.js.map

package/dist/test/transcribe.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=transcribe.test.d.ts.map