@aria-cli/tools 1.0.9 → 1.0.11

package/tests/network-runtime/address-types.contract.test.ts

@@ -1,143 +0,0 @@
-import { describe,expect,expectTypeOf,it } from "vitest";
-import {
-ClientIdSchema,
-ControlEndpointAdvertisementSchema,
-InboxAddressSchema,
-LocalRuntimeSummarySchema,
-NodeAdvertisementSchema,
-NodeIdSchema,
-NodeMetadataSchema,
-PeerTransportIdSchema,
-PrincipalFingerprintSchema,
-RuntimeIdSchema,
-TlsCaFingerprintSchema,
-type ClientId,
-type ControlEndpointAdvertisement,
-type InboxAddress,
-type LocalRuntimeSummary,
-type NodeAdvertisement,
-type NodeId,
-type NodeMetadata,
-type PeerTransportId,
-type PrincipalFingerprint,
-type RuntimeId,
-type TlsCaFingerprint,
-type ToolContext,
-} from "../../src/index.js";
-
-describe("network runtime address contracts", () => {
-  it("exports one canonical remote actor identity through @aria/tools", () => {
-    expectTypeOf<ToolContext["nodeId"]>().toEqualTypeOf<NodeId | undefined>();
-    expectTypeOf<ToolContext["runtimeId"]>().toEqualTypeOf<RuntimeId | undefined>();
-    expectTypeOf<NodeId>().not.toEqualTypeOf<never>();
-    expectTypeOf<PrincipalFingerprint>().not.toEqualTypeOf<never>();
-    expectTypeOf<PeerTransportId>().not.toEqualTypeOf<never>();
-    expectTypeOf<ClientId>().not.toEqualTypeOf<never>();
-    expectTypeOf<NodeId>().not.toEqualTypeOf<PrincipalFingerprint>();
-    expectTypeOf<NodeId>().not.toEqualTypeOf<string>();
-    expectTypeOf<PrincipalFingerprint>().not.toEqualTypeOf<string>();
-    expectTypeOf<TlsCaFingerprint>().not.toEqualTypeOf<never>();
-    expectTypeOf<TlsCaFingerprint>().not.toEqualTypeOf<string>();
-    expectTypeOf<TlsCaFingerprint>().not.toEqualTypeOf<PrincipalFingerprint>();
-    expectTypeOf<TlsCaFingerprint>().not.toEqualTypeOf<NodeId>();
-    expectTypeOf<TlsCaFingerprint>().not.toEqualTypeOf<PeerTransportId>();
-
-    const nodeId = NodeIdSchema.parse("node-alpha");
-    const principalFingerprint = PrincipalFingerprintSchema.parse("principal-alpha");
-    const tlsCaFingerprint = TlsCaFingerprintSchema.parse("ca-alpha");
-
-    // @ts-expect-error NodeId must not accept PrincipalFingerprint
-    const invalidNodeIdFromFingerprint: NodeId = principalFingerprint;
-
-    // @ts-expect-error TlsCaFingerprint must not accept PrincipalFingerprint
-    const invalidCaFromPrincipal: TlsCaFingerprint = principalFingerprint;
-
-    // @ts-expect-error PrincipalFingerprint must not accept TlsCaFingerprint
-    const invalidPrincipalFromCa: PrincipalFingerprint = tlsCaFingerprint;
-
-    expect(invalidNodeIdFromFingerprint).toBeDefined();
-    expect(invalidCaFromPrincipal).toBeDefined();
-    expect(invalidPrincipalFromCa).toBeDefined();
-  });
-
-  it("parses canonical inbox and advertisement shapes", () => {
-    const nodeId = NodeIdSchema.parse("node-home");
-    const runtimeId = RuntimeIdSchema.parse("runtime-a");
-    const clientId = ClientIdSchema.parse("client-a");
-    const caFingerprint = TlsCaFingerprintSchema.parse("ca-fingerprint");
-    const principalFingerprint = PrincipalFingerprintSchema.parse("principal-fingerprint");
-    const transportPublicKey = PeerTransportIdSchema.parse("transport-public-key");
-
-    const clientInbox = InboxAddressSchema.parse({ kind: "client", clientId });
-    const nodeInbox = InboxAddressSchema.parse({ kind: "node", nodeId });
-    const controlEndpoint = ControlEndpointAdvertisementSchema.parse({
-      host: "127.0.0.1",
-      port: 58291,
-      tlsCaFingerprint: caFingerprint,
-      tlsServerIdentity: principalFingerprint,
-      protocolVersion: 1,
-    });
-    const advertisement = NodeAdvertisementSchema.parse({
-      nodeId,
-      principalFingerprint,
-      transportPublicKey,
-      controlEndpoint,
-      displayNameSnapshot: "ARIA",
-    });
-    const localRuntimeSummary = LocalRuntimeSummarySchema.parse({
-      nodeId,
-      runtimeId,
-      lastHeartbeat: new Date().toISOString(),
-      controlEndpoint,
-      displayNameSnapshot: "ARIA",
-    });
-    const metadata = NodeMetadataSchema.parse({
-      nodeId,
-      createdAt: new Date().toISOString(),
-      schemaVersion: 1,
-      migratedFromLegacy: false,
-    });
-
-    expect(clientInbox).toEqual<InboxAddress>({ kind: "client", clientId });
-    expect(nodeInbox).toEqual<InboxAddress>({ kind: "node", nodeId });
-    expect(controlEndpoint).toEqual<ControlEndpointAdvertisement>({
-      host: "127.0.0.1",
-      port: 58291,
-      tlsCaFingerprint: caFingerprint,
-      tlsServerIdentity: principalFingerprint,
-      protocolVersion: 1,
-    });
-    expect(advertisement).toEqual<NodeAdvertisement>({
-      nodeId,
-      principalFingerprint,
-      transportPublicKey,
-      controlEndpoint,
-      displayNameSnapshot: "ARIA",
-    });
-    expect(localRuntimeSummary).toEqual<LocalRuntimeSummary>({
-      nodeId,
-      runtimeId,
-      lastHeartbeat: localRuntimeSummary.lastHeartbeat,
-      controlEndpoint,
-      displayNameSnapshot: "ARIA",
-    });
-    expect(metadata).toEqual<NodeMetadata>({
-      nodeId,
-      createdAt: metadata.createdAt,
-      schemaVersion: 1,
-      migratedFromLegacy: false,
-    });
-    expect(nodeId as string).not.toBe(runtimeId as string);
-    expect(nodeId).not.toBe(runtimeId);
-    expect(nodeId as string).not.toBe(clientId as string);
-  });
-
-  it("rejects runtime-scoped inbox addresses in the shared contract", () => {
-    expect(() =>
-      InboxAddressSchema.parse({
-        kind: "runtime",
-        runtimeId: RuntimeIdSchema.parse("runtime-obsolete"),
-      }),
-    ).toThrow();
-  });
-});

package/tests/network-runtime/continuity-bind-schema.contract.test.ts

@@ -1,203 +0,0 @@
-import { describe, it, expect } from "vitest";
-import {
-  ContinuityStatementSchema,
-  SignedContinuityBindSchema,
-} from "../../src/network-runtime/protocol-schemas.js";
-
-describe("ContinuityStatementSchema", () => {
-  const validStatement = {
-    nodeId: "node-abc-123",
-    previousPrincipalFingerprint: "fp:old-principal",
-    newPrincipalFingerprint: "fp:new-principal",
-    bindingGeneration: 1,
-    createdAt: "2026-03-11T00:00:00Z",
-  };
-
-  it("accepts a valid minimal statement", () => {
-    const result = ContinuityStatementSchema.safeParse(validStatement);
-    expect(result.success).toBe(true);
-  });
-
-  it("requires nodeId as branded NodeId", () => {
-    const result = ContinuityStatementSchema.safeParse({
-      ...validStatement,
-      nodeId: "",
-    });
-    expect(result.success).toBe(false);
-  });
-
-  it("requires previousPrincipalFingerprint as branded PrincipalFingerprint", () => {
-    const result = ContinuityStatementSchema.safeParse({
-      ...validStatement,
-      previousPrincipalFingerprint: "",
-    });
-    expect(result.success).toBe(false);
-  });
-
-  it("requires newPrincipalFingerprint as branded PrincipalFingerprint", () => {
-    const result = ContinuityStatementSchema.safeParse({
-      ...validStatement,
-      newPrincipalFingerprint: "",
-    });
-    expect(result.success).toBe(false);
-  });
-
-  it("requires bindingGeneration as non-negative integer", () => {
-    const negative = ContinuityStatementSchema.safeParse({
-      ...validStatement,
-      bindingGeneration: -1,
-    });
-    expect(negative.success).toBe(false);
-
-    const fractional = ContinuityStatementSchema.safeParse({
-      ...validStatement,
-      bindingGeneration: 1.5,
-    });
-    expect(fractional.success).toBe(false);
-  });
-
-  it("requires createdAt as non-empty string", () => {
-    const empty = ContinuityStatementSchema.safeParse({
-      ...validStatement,
-      createdAt: "",
-    });
-    expect(empty.success).toBe(false);
-
-    const missing = ContinuityStatementSchema.safeParse({
-      ...validStatement,
-      createdAt: undefined,
-    });
-    expect(missing.success).toBe(false);
-  });
-
-  it("allows optional newTransportPublicKey", () => {
-    const withKey = ContinuityStatementSchema.safeParse({
-      ...validStatement,
-      newTransportPublicKey: "transport-key-xyz",
-    });
-    expect(withKey.success).toBe(true);
-
-    const withoutKey = ContinuityStatementSchema.safeParse(validStatement);
-    expect(withoutKey.success).toBe(true);
-  });
-
-  it("allows optional revocationGeneration for revoked-state recovery", () => {
-    const withRevocation = ContinuityStatementSchema.safeParse({
-      ...validStatement,
-      revocationGeneration: 3,
-    });
-    expect(withRevocation.success).toBe(true);
-
-    const withoutRevocation = ContinuityStatementSchema.safeParse(validStatement);
-    expect(withoutRevocation.success).toBe(true);
-  });
-
-  it("rejects unknown fields (strict mode)", () => {
-    const result = ContinuityStatementSchema.safeParse({
-      ...validStatement,
-      extraField: "should-be-rejected",
-    });
-    expect(result.success).toBe(false);
-  });
-});
-
-describe("SignedContinuityBindSchema", () => {
-  const validStatement = {
-    nodeId: "node-abc-123",
-    previousPrincipalFingerprint: "fp:old-principal",
-    newPrincipalFingerprint: "fp:new-principal",
-    bindingGeneration: 1,
-    createdAt: "2026-03-11T00:00:00Z",
-  };
-
-  const validSignedBind = {
-    statement: validStatement,
-    delegationSignature: "sig:delegation-base64",
-    acceptanceSignature: "sig:acceptance-base64",
-    previousPublicKey: "ed25519:old-public-key",
-    newPublicKey: "ed25519:new-public-key",
-  };
-
-  it("accepts a valid signed continuity bind", () => {
-    const result = SignedContinuityBindSchema.safeParse(validSignedBind);
-    expect(result.success).toBe(true);
-  });
-
-  it("requires statement field", () => {
-    const { statement: _, ...noStatement } = validSignedBind;
-    const result = SignedContinuityBindSchema.safeParse(noStatement);
-    expect(result.success).toBe(false);
-  });
-
-  it("requires delegationSignature (not just 'signature')", () => {
-    const result = SignedContinuityBindSchema.safeParse({
-      ...validSignedBind,
-      delegationSignature: undefined,
-    });
-    expect(result.success).toBe(false);
-
-    // A single 'signature' field must NOT satisfy the schema
-    const singleSig = SignedContinuityBindSchema.safeParse({
-      statement: validStatement,
-      signature: "sig:single",
-      previousPublicKey: "ed25519:old-public-key",
-      newPublicKey: "ed25519:new-public-key",
-    });
-    expect(singleSig.success).toBe(false);
-  });
-
-  it("requires acceptanceSignature (dual-signature)", () => {
-    const result = SignedContinuityBindSchema.safeParse({
-      ...validSignedBind,
-      acceptanceSignature: undefined,
-    });
-    expect(result.success).toBe(false);
-  });
-
-  it("requires previousPublicKey for verification", () => {
-    const result = SignedContinuityBindSchema.safeParse({
-      ...validSignedBind,
-      previousPublicKey: undefined,
-    });
-    expect(result.success).toBe(false);
-  });
-
-  it("requires newPublicKey for verification", () => {
-    const result = SignedContinuityBindSchema.safeParse({
-      ...validSignedBind,
-      newPublicKey: undefined,
-    });
-    expect(result.success).toBe(false);
-  });
-
-  it("rejects if delegationSignature is missing", () => {
-    const { delegationSignature: _, ...noDelegation } = validSignedBind;
-    const result = SignedContinuityBindSchema.safeParse(noDelegation);
-    expect(result.success).toBe(false);
-  });
-
-  it("rejects if acceptanceSignature is missing", () => {
-    const { acceptanceSignature: _, ...noAcceptance } = validSignedBind;
-    const result = SignedContinuityBindSchema.safeParse(noAcceptance);
-    expect(result.success).toBe(false);
-  });
-
-  it("rejects unknown fields (strict mode)", () => {
-    const result = SignedContinuityBindSchema.safeParse({
-      ...validSignedBind,
-      extraField: "should-be-rejected",
-    });
-    expect(result.success).toBe(false);
-  });
-
-  it("validates nested statement fields", () => {
-    const result = SignedContinuityBindSchema.safeParse({
-      ...validSignedBind,
-      statement: {
-        ...validStatement,
-        nodeId: "", // invalid: empty string
-      },
-    });
-    expect(result.success).toBe(false);
-  });
-});